Steward: Exploring Intent-Driven Maintenance in the Age of Agentic Coding

Exploring how durable intents and risk signals preserve system direction as AI-accelerated development speeds up.

2026-01-20

Steward: Exploring Intent-Driven Maintenance in the Age of Agentic Coding

Why We Started Thinking About Steward

Over the past year, we have been building production-grade software with an unusually small team—sometimes effectively solo—by leaning heavily on AI-assisted and agentic coding workflows. The productivity gains are real. Features that once took weeks now take days. Complex migrations, UI flows, and backend logic can be scaffolded, revised, and shipped at a pace that would have been unrealistic even a few years ago.

But as velocity increased, a different class of problems became more visible:

Subtle state inconsistencies that are technically correct but conceptually wrong
Features that drift from the original product intent without anyone explicitly deciding to change direction
Systems that “work,” yet are increasingly hard for humans—or AI agents—to explain with confidence

Steward emerged from trying to name and address these problems directly.

The Core Observation: Speed Outpaces Understanding

Agentic coding excels at execution. Given a well-scoped task, an agent can implement, refactor, and test faster than most teams. What it does not naturally do is preserve long-term intent.

In traditional teams, intent is partially carried by process: design reviews, architecture discussions, and institutional memory. In AI-accelerated development, much of that scaffolding disappears. The result is a system that evolves rapidly but accumulates invisible risk.

We repeatedly found ourselves asking questions like:

Why does this state transition exist?
Is this behavior intentional or accidental?
Would an agent make the same change again if prompted today?

Steward is our attempt to make those questions first-class.

Steward Is Not Another Agent

Steward is not a code-writing agent, a monitoring tool, or a dashboard.

Conceptually, Steward sits one level above execution. Its role is to:

Articulate durable intents: truths that must remain valid over time, regardless of implementation
Continuously reason about whether the system still satisfies those intents
Surface risk, not just failure

This framing is deliberate. In complex systems, most real-world failures are not sudden breakages—they are slow divergences from intent.

Intent as a Primitive

A key insight from our work was distinguishing between tasks and intents.

Tasks describe what to do now
Intents describe what must always remain true

For example, “send an email when a match is created” is a task. “Users should never receive surprising notifications” is an intent.

Steward treats intents as durable, reviewable artifacts. Each intent has:

A clear goal
Success criteria
Risk signals
An explicit health state

This allows both humans and AI agents to reason about the system at the right level of abstraction.

A Concrete Example: When the System Is Correct but Wrong

In one real system, matches between two user actions were created automatically via database triggers. From a purely technical perspective, everything was functioning as designed: records were inserted, states transitioned, and no errors were thrown.

Yet users began receiving notifications that felt surprising. In some cases, notifications were skipped entirely. In others, they were sent twice. Debugging revealed no single bug—just a growing gap between what the system did and what the product was meant to guarantee.

The underlying issue was not missing logic, but missing intent. No single place clearly stated:

when a notification must be sent,
when it must not be sent, and
what invariants should never be violated.

Steward reframes this situation by making those guarantees explicit. Instead of asking “did the trigger fire?”, we ask “is the intent Notification Correctness still healthy?”. The answer surfaces risk long before users lose trust.

Why This Matters More With Agentic Coding

As agentic coding becomes mainstream, software creation is no longer the bottleneck. Maintenance, comprehension, and trust are.

Without something like Steward:

Agents optimize locally, not globally
Product philosophy erodes feature by feature
Engineers lose confidence in making changes, even when the system appears healthy

Steward reframes maintenance as an ongoing dialogue between intent and reality, rather than a reactive process triggered by incidents.

Steward in Context

In this model:

Agentic execution moves fast and changes the system
Durable intents provide a stable reference point
Risk signals flow back to humans before failures occur

Steward lives in this feedback loop.

A Real-World Constraint: Solo and Small Teams

Steward is explicitly designed for environments where:

There is no dedicated platform or reliability team
Context switching is expensive
The same person designs, builds, and operates the system

In these settings, comprehensibility is not a luxury—it is a survival requirement. If neither the developer nor the agent can confidently explain why the system behaves the way it does, velocity eventually collapses.

Closing: Speed Needs Direction

Agentic coding has removed execution as the primary constraint in software development. What remains is judgment: knowing what should not change, even as everything else does.

Steward is our working response to that reality. It is not about slowing teams down or constraining agents. It is about preserving direction, intent, and trust as systems evolve faster than any individual can fully hold in their head.

As software development enters this next phase, we believe intent-driven stewardship will become as fundamental as version control or testing—not as an afterthought, but as a prerequisite for sustainable speed.