Context is the new bottleneck in AI-assisted software development. AI agents can now draft requirements, propose architecture, and generate code and tests in a fraction of the time those steps used to take. When building gets that cheap, the expensive mistake is building the wrong thing quickly.
Good context has three layers. Problem context names the need behind a feature request, in the user's own terms. People context covers who is affected, what they do today, and the gap between what they say and what they do. Process context maps how work flows before any tool touches it. A gap in any layer shows up later as rework.
Teams build context on purpose through three habits. They make discovery a repeatable practice every cycle. They keep context in shared artifacts that people and agents can both use. They run feedback loops that keep those artifacts current. Frameworks like AWS's AI-Driven Development Life Cycle (AI-DLC) add structure from intent to working software. However, what comes out is only as good as the context behind the intent that goes in.
Your team can now turn a rough idea into working software faster than ever. AI agents draft requirements, propose architecture, and generate code and tests in a fraction of the time those steps used to take. When building gets that cheap, the expensive mistake is building the wrong thing quickly.
The scarce skill has moved upstream. It’s knowing what to build, who it’s for, and why it matters. That depends on context, and most teams still gather it in a rush at the start of a project and rarely go back.
Cheap building moves the risk upstream
For most of software’s history, writing code was the slow, costly part. Teams planned around it. Long requirements phases existed because a wrong guess meant months of rework.
That cost has dropped. In the work I see, coding is rarely the slowest step anymore. The bottleneck is usually discovery: recruiting users, running interviews, and agreeing on what to build. AI helps with synthesis, but people still have to do that work.
Think about building a house. If a crew could frame one in a weekend, you’d still need to talk with the family who will live there. Skip that conversation and you just get to the wrong kitchen faster.
Faster building also raises the stakes on bad input. An agent given a vague request will produce something that matches the request. It will look finished, and it may even pass its tests. If the request missed what users needed, you now have polished software that solves the wrong problem, and you got there faster.
That changes the constraint for your team. Speed matters less now. How well you understand the problem before the agents start matters more.
Good context has three layers
Context is a loose word. I break good context into three layers: problem, people, and process. A gap in any one of them shows up later as rework.

Image 1.0 - The Three Layers of Good Context
Problem: the need behind the request
A feature request is a proposed solution. Someone asks for an export button, a new dashboard, or an approval workflow. Behind each request is a need the person may not have put into words. Maybe they export data because the report they need doesn’t exist. Maybe they want a dashboard because they don’t trust the numbers they get today.
Good problem context names that underlying need in the user’s terms. It also says what happens if you don’t solve it, so your team can tell a real problem from a nice-to-have.
A simple test: if you can’t state the problem without mentioning the feature, you don’t have problem context yet.
People: who’s affected and what they actually do
Software lands on people, and usually on more of them than the request mentions. The person asking may not be the person using it. The person using it may not be the one who lives with the output. If you only interview the person who asked, you get one view of the problem, so talk with the people downstream too.
People context covers who is affected, what they do today, and the gap between what they say and what they do. That gap matters most. Ask someone how they handle a task and they’ll describe the official process. Watch them do it and you’ll see the spreadsheet on the side, the sticky note on the monitor, and the coworker they message when the system gets it wrong. Those workarounds are where the real requirements hide.
This is why interviews and observation still matter on an AI project. An agent can summarize a stack of interview transcripts. It can’t sit next to someone and notice the step they forgot to mention.
Process: how work flows before any tool touches it
Process context is how work moves from start to finish today, before any tool touches it. Where does a request start? Who handles it, and in what order? Where does it wait? What triggers an exception, and who deals with it?
Teams often skip this step because the current process looks obvious, or because everyone already agrees it’s broken. Map it anyway. If you automate a step without knowing what feeds it and what depends on it, you can make that step faster and slow down the whole flow. You may also automate a step that shouldn’t exist.
Start with one workflow that matters and walk it end to end with the people who run it. That map can settle arguments that would otherwise surface in code review.
How the layers check each other
The three layers work best together. A problem statement that nobody on your people list would recognize is probably your team’s guess. A process map that leaves out the workarounds you saw during observation is the version on paper. Your agents will build to whatever version you give them, so give them the one people use day to day.
How your team builds context on purpose
Most teams treat discovery as a phase. It happens at the start, produces a document, and ends. That made sense when building took months and the plan had to hold the whole time. With AI, your team may ship several versions in the time an old discovery phase took, and context gathered once goes stale fast.
Building context systematically comes down to three habits.
Make discovery a repeatable practice
Treat discovery as something your team does every cycle, in small amounts. Before each meaningful piece of work, ask what you need to learn and who you need to talk to. Sometimes that’s one conversation with a user. Sometimes it’s an hour watching someone work.
Put it on the calendar. A standing weekly slot for user conversations keeps discovery from getting squeezed out when delivery picks up speed. Keep the questions short and tied to the decision in front of you.
A small team can do this. It needs someone who owns the question, usually a product manager or designer, and protected time to go ask it.
Keep context in shared artifacts
Context that lives in one person’s head disappears at the first handoff. Agents make that worse, because an agent only knows what you give it.
Write context down in forms your team and your agents can both use:
A short problem statement in the user’s words
A list of the people affected and what each one does today
A current-state process map
Notes that separate what users said from what you observed
Keep these plain and short, and store them where your team keeps requirements and prompts. They carry intent from the person who ran the interview to the person, or agent, who builds the feature. They also give reviewers something to check the output against.
Build feedback loops that keep context current
Context changes. People change how they work once a new tool arrives. One workaround disappears and another shows up. A stakeholder who wasn’t in the first conversation turns out to own a critical step.
Build loops that bring that back to the team. After each release, look at how people use what shipped, and talk with a few of them. Compare what you learn with the artifacts you wrote. When they disagree, update the artifacts first, then decide what to build next.
If your problem statement hasn’t changed in months while the product has, treat that as a sign the loop has stalled.
Where frameworks like AI-DLC fit
Once your team has a way to build context, the next question is how to keep that work consistent as AI takes on more of it. There are many frameworks out there that can help. A good one gives people and agents a shared set of steps, so the quality of the work doesn’t depend on who runs it that day.
One such framework is AWS’s AI-Driven Development Life Cycle, or AI-DLC. AWS first described it in a July 2025 DevOps blog post with three phases. The current open source version, AI-DLC Workflows, is published by AWS Labs on GitHub. It has five phases and 33 stages: Initialization, Ideation, Inception, Construction, and Operation, with approval gates between phases.
It’s a thoughtful framework. It lays out how AI and people move from a stated intent through requirements, user stories, domain design, code generation, testing, and deployment, with points along the way where people approve the work. For a team that already knows what it needs to build, that structure can take a lot of friction out of delivery. Clear stages and approval gates also make it easier to see where the work stands and who signed off on it.
It’s worth looking at where it starts. After the setup stages in Initialization, the first stage is 1.1 Intent Capture and Framing. That stage asks your team to state what it wants to build and why. It’s the right question, and the answer is only as good as the context behind it. Ideation includes a conditional Market Research stage. Inception includes Reverse Engineering for existing code and a conditional Practices Discovery stage. The stage list doesn’t name a stage for user interviews or for observing how work gets done today, and no phase is called Discovery.
That fits a delivery framework. AI-DLC is built to turn intent into working software. However, it means the quality of what comes out depends on the quality of the intent that goes in. The framework will carry a weak understanding through its stages as efficiently as a strong one.
That’s where your team’s judgment, taste, and human-centered research earn their keep. AI-DLC is open source, so any team can adopt the same workflows. The difference between two teams running it will come from how well each one understood the problem, the people, and the process before Intent Capture began.
What comes next
The three layers of context connect directly to AI-DLC’s phases, from Intent Capture in Ideation through the feedback work in Operation. In a follow-up, I’ll map those plug-in points one by one.
Sources
Raja SP, “AI-Driven Development Life Cycle: Reimagining Software Engineering,” AWS DevOps & Developer Productivity Blog, July 31, 2025: https://aws.amazon.com/blogs/devops/ai-driven-development-life-cycle/
AWS Labs, AI-DLC Workflows documentation: https://awslabs.github.io/aidlc-workflows/
AWS Labs, AI-DLC Workflows guide, “Phases and Stages” (v2): https://github.com/awslabs/aidlc-workflows/blob/v2/docs/guide/04-phases-and-stages.md
AWS Labs, aidlc-workflows repository on GitHub: https://github.com/awslabs/aidlc-workflows

