What fully autonomous software engineering requires

Fully autonomous software engineering is the goal

Descant’s North Star is fully autonomous software engineering: a system that can carry an engineering goal through implementation, review, integration, and maintenance, with people setting direction and retaining authority over its boundaries.

Sustained engineering across an entire codebase is a necessary capability on that path. Real software evolves over weeks, months, and years. Requirements change, technical debt accumulates, and each completed change alters the work still to come. The system has to preserve architectural intent while adapting to what it discovers.

Completing one difficult coding task demonstrates a useful capability. Carrying a codebase through thousands of coordinated changes requires continuity: the ability to decompose goals, relate work, implement and review, groom and learn, and repeatedly converge as the product changes. That lifecycle is the framework we are building into Descant.

Turn a goal into coordinated work

Descant assesses whether an eligible issue is too large for a focused pull request. Oversized work is decomposed into smaller issues with explicit scope and relationships. A single product brief can grow into hundreds or thousands of issues as requirements are broken down and implementation reveals missing pieces. Small pull requests keep that effort incremental and reviewable.

Issuegraph frontmatter and labels make the plan machine-readable: where work was decomposed from, what belongs together, what must be serialized, and what is blocked by a dependency. These relationships let the system coordinate changes without losing their connection to the original goal.

Implementation and separate review operate within the current issue’s scope. Tangential fixes, technical debt, and out-of-scope improvements become follow-up issues. Leaving the codebase better includes preserving those discoveries so they can be prioritized and addressed.

The same discipline matters in an established enterprise system. A large technical-debt backlog needs careful sequencing and architectural continuity. Replacing a shared contract, migrating its callers, and retiring the old implementation are related changes whose order matters. Sustained engineering carries that sequence through while keeping each individual change focused.

Learn, reconcile, and converge again

Every completed change affects the surrounding backlog. Related issues may need updated context, narrower scope, a new dependency, repurposing, or closure because their work is already satisfied. Grooming reconciles those issues and records relationships at the edges as they become apparent.

Documented learnings carry architectural decisions, repository conventions, and resolved review findings forward. Incremental compression and relevance updates keep that knowledge useful as the codebase evolves. Analysis of pipeline runs also surfaces opportunities to improve quality, cost, and efficiency. Each run should leave the next one better informed.

The result is repeated convergence. Discovering necessary work can expand the backlog before implementation catches up. As related changes land and residual work is resolved, the system converges on a working product. New requirements begin another cycle, with the existing code and accumulated knowledge as its foundation.

We develop the next generation of Descant through this process on TriviaPot, OH HAI, and Descant itself. TriviaPot reached a working product through an in-place rebuild, then went through a deliberate design overhaul. OH HAI grew from a small set of product-level issues into an application, service, CLI, and agent integrations.

That is why sustained engineering matters to the larger goal. Fully autonomous software engineering requires a system that can keep bringing real work to completion as the codebase changes. Our focus on convergence is bringing that system closer to closed beta.