As AI continues to improve daily, traditional software development life cycles, which rely heavily on human involvement, are becoming outdated. This shift is driven by the rapid adoption of agentic software development and the increasingly unclear role of humans in the loop. While we focus heavily on prompting the frontier models to retrieve the required data, the real artifact here is not the data but merely a side effect of the decision tree made by the human in the loop. This decision tree has always existed, but the current tendency to preserve it is beginning to affect the software development life cycle. Agile methodologies emphasized the need for humans to iterate on code based on sprints, which focused on record-keeping rather than reasoning. Now, with agents integrated into the cycle, the question arises: what should humans be iterating on?
SPEC → Decision Trees → Product
The SPEC first model focuses on creating the specs, which over time accumulate to become content graphs for enterprises to trace the business logic of the product. While people can be confused about defining SPEC as the same as writing a PRD, the fundamentals of a SPEC are essentially different. A PRD is written for a human to interpret, whereas the SPEC is written for an agent to act on and a human to audit.
The SPEC can be broken down into three components:
- The business contract
- The decision tree
- The outcome validator
Each of the key players in the software development cycle gets the SPEC to evaluate business decisions, generate code, evaluate the product, and define new components. The tracing of decisions and generating/regenerating code becomes much simpler than before, as the code is never the primary artifact here. The reviews are on the SPEC differences rather than pull requests. All the technical debt resides in ambiguous SPECs and not in sprawling codebases.
Over time, this SPEC-first development results in the SPEC forming a context graph, making it an organizational memory. This enables a user to query about the system and why it is the way it is. The human capital is shifted towards defining the rationale, and the agentic capital will focus on generating the byproduct. The significant advantage of the model is that all the exceptions become searchable precedents instead of dying institutional memory that gets erased over time.
Humans own the why, agents own the how
The ongoing discussion about agents replacing humans is primarily focused on code generation. However, the entire orchestration operates at a SPEC level, where humans are responsible for defining these specifications. This process ensures that the agents are guided by an intent regarding the desired outcome, rather than just the outcome itself.
This shift changes the roles of the team members. Senior engineers and product managers will concentrate on defining and refining the specs, while junior engineers will manage the orchestration of the agents and address any ambiguous specs that arise. The context graphs created during this process serve as an audit trail and ensure compliance within the organization.
Final Thoughts
Every shift in the paradigm presents a challenge, and in this case, it's the issue of context graph bloat. Every judgment has a shelf life, and a graph that isn't regularly pruned becomes a stale cache instead of an effective decision aid. Agents querying these graphs may produce outdated rationales with the same level of confidence as the current business logic. Therefore, it's crucial not only to define good specs but also to know when it's time to retire them.