.png)
The Poll That Framed the Whole Session
In the webinar, the audience was asked to rate the impact of the current state of their tickets on their team's delivery. The results framed the reason behind this topic.
Roughly half of the audience of engineering, product, and agile coaches in the session said their current ticket quality creates noticeable drag on the sprint, or is actively putting commitments at risk. Nobody said their tickets were clean.
That result aligns with what most engineering managers already feel during stand-ups. PRs are moving, the team is busy, the agentic tooling is humming. Sprint attainment still wobbles. Rework keeps showing up late in the cycle. The gap between "we shipped a lot" and "we shipped the right thing" is widening.
The argument of the session, in one line: Bad specs equals bad AI coding quality. In other words, the quality of your tickets is the quality of your software. AI coding agents are a multiplier of the good or the bad.
Below are the three takeaways worth bringing back to your team. Give it a listen for yourself.
Takeaway 1: "Almost Right" Is the New Failure Mode
66% of developers said AI output is "almost right, but not quite" (Stack Overflow 2025). Two-thirds of your team's agent output lands close enough to feel productive and far enough from correct to need rework.
The DORA 2025 data sharpens the picture. Tasks completed per developer up 21%. PRs merged per developer up 98%. Developers report feeling around 20% faster (METR 2025). At the same time, measured delivery stability declined while org-level throughput stayed flat.
For an engineering manager, that pattern explains a lot. The individual metrics say the team is faster than ever. The sprint says otherwise. The tooling is working for the contributor and breaking for the team, because the rework volume per feature has quietly doubled. The bottleneck did not disappear; it moved.
Takeaway 2: The Engineer's Safety Net Is Gone
Before agentic tooling, the engineering loop had a built-in gap-filler. Product dropped a ticket, the engineer read it, asked clarifying questions in Slack, pattern-matched against the last six months of the codebase, and filled in the pieces the ticket never captured. Bad tickets shipped working code because a senior engineer absorbed the ambiguity.
The agentic loop skips that step. The agent reads the ticket and writes plausible code immediately. No Slack thread with the PM. No decade of context in the reviewer's head, correcting course at refinement. Minimal clarifying questions and lots of assumptions. "Almost right" now happens earlier, faster, and at volume, and it bypasses the human checkpoints that used to catch it.
One attendee said it crisply in chat, and it is worth stealing: accountability does not transfer to the model. The agent can assist and accelerate. The team still owns the outcome. In the old loop, that was implicit. In the agentic loop, it has to be engineered in.
For engineering managers, this is the first place to look when sprint commitments start slipping in an AI-heavy team. The refinement process that worked at human speed cannot keep up with machine-speed code generation.
Takeaway 3: Context Is the Bottleneck, Not the Model
Jeff walked through the seven context layers that a senior engineer actually brings to a code review. Most AI tools see one or two of them. Full context, the context graph a senior engineer carries into review, includes:
- Acceptance criteria and edge cases
- Technical documentation and API references
- System design, patterns, and dependencies
- Past rework, failure modes, and code churn
- Reported issues and feature requests
- Epic intent and product strategy
- Business objectives and success metrics
An agent grading a ticket against one of those seven layers will miss the other six every time. The gap shows up as duplicated code (copy-paste volume up roughly 8x per GitClear), refactoring collapsing, and a codebase that rots faster than it ships.
The punchline for engineering managers: model choice is a commodity decision at this point. Ticket quality is the leverage. The teams that provide their agents with the full context of the work are the teams whose sprint commitments hold; the teams that provide their agents with a two-paragraph Jira ticket are the teams running the rework treadmill.
The Short Version for Your Next Sprint Retro
The teams that instrument ticket hygiene before their agents scale are the teams whose sprint commitments hold under agentic load. The ones that wait for the rework curve to bend back on its own will keep paying for it in stability, throughput, and reviewer fatigue.
Watch the on-demand webinar for the full details and the live demo walkthrough of what Allstacks is doing to make sure your tickets don't suck.
FAQ
How does ticket quality affect AI code quality?
AI coding agents amplify whatever ticket quality they receive. Before agentic tools, a senior engineer would fill in gaps left by a vague ticket — asking clarifying questions, pattern-matching against the codebase, and absorbing ambiguity before writing a line of code. Agentic tools skip that step. They read the ticket and generate plausible code immediately, which means bad tickets produce almost-correct code at machine speed and volume, bypassing the human checkpoints that used to catch the errors before they reached review.
Why do sprint commitments still slip when teams are using AI coding tools?
Individual output metrics rise sharply with AI tools — DORA 2025 found tasks completed per developer up 21% and PRs merged up 98% — but delivery stability declines and org-level throughput stays flat. The gap is hidden rework. AI agents produce output that is close but not correct, so the rework volume per feature increases even as contributors feel faster. The bottleneck moves from writing code to reviewing, correcting, and re-merging it. Sprint attainment suffers because the volume of work entering review is higher, and the error rate per unit of work has not dropped.
What context do AI coding agents need to produce accurate code?
A senior engineer carries seven layers of context into a code review that most AI tools never see: acceptance criteria and edge cases, technical documentation and API references, system design and dependencies, past rework and failure modes, reported issues and feature requests, epic intent and product strategy, and business objectives and success metrics. An agent working from a single Jira ticket sees one or two of those layers at most. The gap shows up as duplicated code, collapsing refactoring rates, and a codebase that accumulates technical debt faster than it ships features. For a practical framework on structuring specs for agents, see How to Write Specs for AI Agents: TDD, Skills, and What Comes Next.
What is the Allstacks Spec Readiness Agent?
The Allstacks Spec Readiness Agent reads your tickets against the full context layers a senior engineer would use in review and grades whether a body of work is ready for an AI coding agent to execute. It operates in three modes — epics, sprints, and individual tickets — and surfaces readiness gaps before the coding agent picks up the work. The goal is to move the quality gate upstream of code generation, so agents are building from specs with enough context to produce correct output the first time.
What did the DORA 2025 report find about AI and software delivery?
The DORA 2025 State of AI-Assisted Software Development report found that AI coding tools produce significant individual-level productivity gains — tasks completed per developer up 21%, PRs merged per developer up 98% — but those gains do not translate to organizational delivery improvement. Delivery stability declined, and org-level throughput remained flat. The report characterizes this as an AI productivity paradox: AI accelerates software development but exposes weaknesses downstream when the upstream inputs, including ticket quality and spec clarity, are not addressed.
Who is accountable for code quality when an AI agent writes the code?
The engineering team remains accountable for code quality regardless of whether a human or an AI agent wrote the code. Accountability does not transfer to the model. In a traditional engineering loop, accountability was implicit because a senior engineer filled in gaps and corrected course during review. In an agentic loop, that accountability has to be engineered explicitly — through spec-readiness gates, context-grounded inputs, and structured review checkpoints — because the agent will not ask clarifying questions or flag missing context on its own.