English | EN 
Artificial intelligence has introduced a new level of acceleration into software development lifecycles. Across industries, organizations are evaluating not only what these tools can produce, but also how reliably those outputs can be understood, validated, and integrated into existing systems. In software, this distinction matters. The value is measured by how consistently people can interact with it, reason about it, and trust it within a broader engineering process.
Software development has long depended on abstraction. At its simplest, abstraction is the practice of hiding complex implementation details so that developers and users can focus on essential behavior and high-level interaction. A function, service, or interface can be treated as a reliable component if its inputs and outputs are consistent. Once that reliability exists, the component can be reused, composed, and scaled into more elaborate systems.
This principle is foundational to modern software. User interfaces, libraries, SDKs, APIs, services, and infrastructure patterns all rely on the same assumption: if a system behaves consistently, users do not need to understand every internal mechanism to leverage it effectively. This is how software scales from individual functions to platforms that serve millions of users.
Agentic tools complicate this model because their interfaces and outputs are less deterministic than traditional software components. The models are inherently probabilistic. Their outputs may be useful, but they are not always reliable in the same way a deterministic function is. As a result, the AI operator must validate work that can now be produced faster than ever before. While we are excited by the promise of improved delivery, this approach cannot scale beyond what an AI user can review.
This raises a concern: if we are advocating for the widespread adoption of agentic development to empower our developers, it cannot come at the cost of their productivity. When a developer uses an agent through prompts, there is a significant burden to steer, direct, and especially validate the agent. This does not scale in the way we know software systems can scale.
This is where our topic of abstraction comes back into the picture. Instead of focusing on precise prompting and tedious manual reviews, we can put the computational burden back inside software systems. Then, we can use those same systems to validate our expectations at scale.
Spec Driven Development
By defining system designs in a single, persistent location, we can avoid the pitfalls of more informal prompt engineering. This practice is becoming known as Spec Driven Development.
GitHub is pioneering this process and has released a tool called Spec Kit, which “provides a structured process to bring spec-driven development to […] coding agent workflows.” [1]
Ideally, all software development would be driven through this specification document. It would be a living, evolving source of truth that clearly describes the expected behaviors, design decisions, and requirements of an application or system.
This specification can then be used to derive:
- Detailed implementation plans
- Expected software behavior and business logic
- Data models and API contracts
- Comprehensive unit tests and validation criteria
When design expectations change, AI agents can use the updated specification as the source of truth and propagate those changes into workable code. This keeps implementation aligned with intent while reducing the need for developers to manually restate requirements across each layer of the system.
By combining the generative properties of AI agents with the formalization and standardization of a specification, we can create a useful balance. Developers can stay hands-off for details that are not yet relevant while still communicating a consistent intent across versions, which is essential for ensuring correct system behavior.
This also helps address the problem of context permanence. Proficient agentic development requires context management, such as fine-tuning the model, supplying instructional context, or directing the agent toward reference material. Most of the time, this means the AI operator needs to be careful about the instructions they provide, which further adds to the cognitive load.
By formalizing the context and baking it into the process, every agentic decision can be traced back to its origin. This is similar to Infrastructure as Code, where cloud services can be managed from a code document. That code can then be managed through version control, allowing developers to benefit from:
- Full History – the Git tree can show each individual change
- Easy Recovery – If the system breaks, it can be rolled back to a stable version
- Collaborative – Multiple people can work in the same project space, and reconcile differences in implementation
By leaning into our goal of abstraction, we’re able to make the overall process more consistent and reliable.
Conclusion
AI users can still generate code with great ease using traditional “vibe coding.” Through Spec Driven Development, they can also follow up programmatically with the validations needed to ensure the system is working correctly. With this kind of process in place, we can start treating AI models as part of a larger ecosystem, rather than as a silver bullet that will solve every problem.
What is the takeaway as a developer? Start by shifting prompting into formalized documents, which can be used as the source of truth for development goals.
When both sides of the software development feedback loop are supported, developers can remain focused on the problems that matter most. The burden shifts from steering an agent with verbose prompts to trusting agents with clear intent. Those intentions are then validated by checks and balances that make the model’s output easier to trust.
This is the promise of generative AI in software development. With the right abstractions, specifications, and validation systems in place, developers can use AI as a dependable partner: one they can rely on, guide confidently, and trust to help move the work forward.
References
- Spec-driven development with AI: Get started with a new open source toolkit – https://github.blog/ai-and-ml/generative-ai/spec-driven-development-with-ai-get-started-with-a-new-open-source-toolkit/