Skip to the cards
Filed
Source
David Garcia
Loans
990

Coding Agents Could Put Software Specifications at the Center of Development

Coding agents may shift the work from writing code to refining specifications, testing results and agreeing on customer feedback.

Coding Agents Could Put Software Specifications at the Center of Development

Coding agents could change software development by making implementation much faster, shifting more of the work toward defining what an application should do. That raises a practical question for development teams: should they keep iterating on code, or make the specification the main thing they refine?

The answer may combine ideas from two established approaches. Waterfall tried to settle requirements before implementation, while Agile methods made room for frequent feedback and changing needs. With agents able to generate code from a specification, teams may be able to define requirements in detail and still revise them as customers respond to working software.

When implementation was the bottleneck

Waterfall arose when writing and testing software took so much effort that teams tried to resolve requirements up front. They produced a detailed specification, handed it to developers, and passed the resulting application to testers before delivery. That sequence could leave a project late and out of step with what customers wanted. A change made after the specification was approved could mean extra time and cost.

Agile offered a different emphasis. Software teams could work in shorter cycles, respond to feedback and adjust course instead of treating the initial plan as fixed. The Agile manifesto helped popularize approaches such as Scrum, and its preference for working software over extensive documentation became a touchstone for many teams.

Now the premise behind that preference may be changing. If coding agents reduce the effort needed to build an application, implementation may no longer set the pace. The bigger challenge could be deciding what to build, expressing those requirements clearly and confirming that the result meets customer needs.

Two ways to iterate on a specification

One possible process keeps customers closely involved in approving both requirements and results. The team writes a specification, gets customer agreement, asks an agent to build the application, and gathers feedback on the result. The specification is updated, reviewed with the customer, and used for another build. This cycle continues until the customer is satisfied.

A second approach gives customers a working application to review without asking them to approve each specification change. The team still treats the specification as the source of truth, updating it after feedback and using it to guide each new implementation. This could make customer review more focused on whether the software works for them, though the team would still need a reliable way to capture what they expect.

Both processes blend familiar ideas. A detailed specification recalls Waterfall; repeated delivery and customer feedback reflect Agile. The emerging label spec-driven development points toward that mix. If an agent can generate working software quickly, teams may revisit the Agile preference for software over documentation. The specification could become more than a planning document: it might serve as the application’s definition.

What becomes the source of truth?

If the specification defines the application, teams will need to decide how to manage changes to it. Should it be version controlled? Should edits go through pull requests and review? Those practices could make the specification easier to audit and discuss, especially when a change affects multiple parts of the application.

The generated code raises a related choice. A team could discard each implementation and have an agent rebuild from the latest specification. That offers a clean start, but agents can produce different results, making consistency a concern. Alternatively, the agent could modify its existing implementation, closer to the way teams work today. A third option would ask the agent to use its prior work and the revised specification to redesign the application.

Teams might also compare these approaches on the same project. The author’s suggestion is to try all three and assess the results. That could help teams learn where a fresh build, incremental changes or a redesign works best. The trade-off is that comparing multiple implementations still requires time to review them and decide which meets the specification.

Tests may define expected behavior

Testing could become a larger part of this process. Agents could write unit, integration and end-to-end tests from the specification, giving teams a way to check each new implementation against the same expected behavior. That could make it easier to rebuild or substantially revise an application, provided the tests cover the requirements that matter.

This raises the possibility of making tests part of the application’s definition. A specification describes what the software should do; tests translate some of those expectations into checks. But tests can only verify what the team has expressed clearly enough to test. They won’t automatically settle subjective questions or reveal requirements that were never captured.

More tests may also help with the move from development into maintenance. Still, a large test suite does not remove the need to assess whether the application’s behavior, design and operating characteristics match customer expectations.

Customer feedback and human judgment remain constraints

AI could help turn customer discussions into specification updates. A team might record conversations and use AI to draft changes based on what participants said. That could reduce the effort of writing and revising requirements, but it would not eliminate the need to confirm that the specification reflects what the customer intended.

Customer attention could become a limiting factor. If teams can produce new versions quickly, customers may face more frequent requests to review them. The development cycle could speed up while the time available for meaningful feedback stays much the same.

Language itself is another constraint. Natural language can be ambiguous, and software specifications need enough precision to guide implementation. Edsger W. Dijkstra raised this concern in “On the foolishness of ‘natural language programming’”. Teams may need structured requirements, explicit examples and tests alongside prose to reduce the risk of different interpretations.

Some requirements are also difficult to define completely in advance. Look and feel, security, performance and accessibility can be hard to express as precise instructions. Human judgment will still matter in reviewing those qualities and deciding whether the result is suitable.

Costs, existing code and the shape of applications

Agent capacity has a cost, even if the price of using coding agents may fall. Teams will need to track those costs and compare them with the time and effort saved. The economics may look different for a new application than for a large existing codebase, where accumulated design choices and dependencies could limit how much a specification-driven process changes the work.

Frequent regeneration also puts pressure on user experience. Customers may not accept an interface that changes unpredictably with each iteration. Teams will need to keep the front end consistent while allowing the application to evolve; the division between front-end and back-end work may need to reflect that goal.

There is also the question of who can diagnose a production issue if an agent wrote the code and the team has paid little attention to its details. An agent may be able to help fix a bug, but teams still need to understand how the application behaves and how to assess a proposed repair.

Coding agents don’t settle whether Agile or Waterfall is the right model. They may change which parts of each approach are useful: detailed specifications could become cheaper to produce, while rapid implementation could make customer feedback more frequent. For teams starting new projects, the practical next step is to decide how specifications, tests, reviews and generated code will fit together—and how they’ll keep customer feedback manageable.

Source: David Garcia · www.infoworld.com

Filed alongside