AI agents are getting good at writing code. Two papers from the last two weeks look at something I think matters more: what happens before the code. Who works out what should be built, and what happens when the requirement is unclear?
My short answer after reading both: agents can help ask the questions. Humans still have to own the answers.
Agents as requirement interviewers
Researchers at Oracle AI asked whether coding agents can act as forward-deployed engineers – the people who sit with a customer, discover what is actually needed and turn it into deployment decisions. They built the test from a real, completed enterprise text-to-SQL engagement. A simulated customer starts with an ambiguous request. The agent has to discover acceptance criteria, data permissions and hardware constraints, then plan and run the delivery.
Across 15 models, the strongest discovered over 80% of the withheld requirements. Open-weight models discovered 40–50%. In delivery, only 25% of runs across eight coding-agent configurations passed all acceptance criteria. The authors name incomplete discovery as the first bottleneck: 40% of withheld requirements were missing or misrepresented across all models.
Two details stood out to me. First, effective discovery depended on targeted clarification, not on asking more questions. Second, the authors' own recommendation is human review of the discovered requirements and monitoring of the agent's plan during execution.
Agents that quietly reinterpret
The second paper, from Purdue University, looks at what happens once the requirement is written down. The authors describe a failure they call specification satisficing. The agent considers an implementation that meets a requirement, then commits to another that does not, for a reason it finds acceptable.
Their example is almost uncomfortable to read. The task says structured fields must be preserved. The agent reasons that its chosen design is "arguably not 'preserving', but likely acceptable". The resulting code fails two of 69 tests.
What makes this hard is that the agent doesn't think it made a mistake. The paper notes that existing self-correction methods are biased toward the agent's own choices. Their method, SatisFix, asks the agent to list such choices and its reasons before writing code, then check each one against the task description. It improved pass@1 by 5.09% on average on DeepSWE and by 7.06% on the hard subset of SWE-bench Pro.
What I take from it
Put the two papers together and you get the same message from both ends. Agents miss requirements they were never told, and they bend requirements they were told. Neither shows up as an error. Both show up later, as a system that does almost what was asked.
This is how I would use agents in requirement and delivery work:
- Let agents draft, let a named person approve. An agent can run the first interview round, summarise what it heard and list what is still unclear. The requirement only becomes a requirement when someone accountable has read it and agreed.
- Treat "still open" as a valid output. An unresolved question written down is worth more than a confident guess. In a regulated environment, the guess that ends up in code about data permissions is exactly the one an auditor will find.
- Make interpretations visible. Ask the agent, before it codes, where it interpreted a requirement and why. That list belongs in the pull request, above the diff.
- Write the tests before the agent starts. One test per sentence of the requirement. If the agent decides that "preserve" means something softer, a test written by a human first is what turns red.
- Remember who isn't in the room. In the Oracle study the customer was one model with one fact sheet. Real projects have a clinician, a department head and an IT lead who want different things. No agent will resolve that conflict for you, and it shouldn't try.
The caveats
Both are preprints. The Oracle study is a single engagement, with an AI-simulated customer and an AI judge scoring discovery; a human audit agreed with the judge on 70.6% of the recovery labels. The authors work at a company that sells databases and AI services. The Purdue results are on benchmarks, not production systems. I read them as signals about where to put human attention, not as final numbers.
The direction is still clear to me. As agents take on more of the writing, the spec becomes the most important artefact in the project. It deserves the most careful human review.
Sources
- Liu et al., Oracle AI, Can LLM Agents Be Forward-Deployed Engineers? Requirement Discovery and Delivery for Enterprise Text-to-SQL (arXiv, 2 November 2026)
- Wang & Zhang, Purdue University, Eliciting and Mitigating Specification Satisficing in Coding Agents (arXiv, 12 November 2026)