From Prompts to Agentic SDLC
- date
- category
- AI Agents
- reading
- 4 min / 765 words
Most developers went through a similar path.
First we opened ChatGPT in another tab. We copied a piece of code, a stack trace or SQL, got an answer and moved it back into the IDE.
Then models started receiving more context. Claude Code appeared. AI stopped only answering questions and gained access to the repository, shell, git and tests.
Then another problem appeared: if Claude can do the work, it needs to learn the project. Then it needs access to information outside the repository. Then repeated ways of working need to be written down. Large tasks need to be split into separate contexts. Eventually you need to stop assuming that an LLM will remember every instruction from the start of a conversation after an hour of tool calls.
This series is about that evolution.
It is not a course for juniors. It also does not assume that you already know agents, MCP or RAG. The point of reference is the ordinary SDLC that almost every developer knows:
task
-> analysis
-> implementation
-> tests
-> review
-> fixes
-> CI
-> PR
-> deployment
-> maintenance
AI can help at every one of these stages. The question is: how do you stop using it as a better autocomplete and start systematically improving the way you work?
How to read this series
Each article describes one level.
You do not have to start from the first one. If you recognize your current way of working in one of the articles, start there.
Each level has the same shape:
- How we work today
- What starts getting in the way
- What mechanism solves the problem
- What it looks like in everyday SDLC
- What to implement in your own setup
- How to check that you really moved one level up
The most important rule of this series:
After reading an article, something in your repository or daily SDLC should work differently than before.
If you only learned a new word and your way of working did not change, the level is not complete.
Series map
LEVEL 0
Chat / copy-paste
|
| 1. Claude Code
v
AI performs a task in the repository
|
| 2. CLAUDE.md + context engineering
v
Claude understands the project and its rules
|
| 3. Search / retrieval / RAG / MCP
v
Claude gets the information it needs
|
| 4. Skills, Hooks and Permissions
v
Claude knows the method, automation and boundaries
|
| 5. Subagents
v
Large work goes into separate contexts
|
| 6. Dynamic Workflows
v
The workflow no longer depends on LLM memory
|
| 7. Managed Agents
v
Execution no longer depends on your laptop
|
| 8. Beyond Dynamic Workflows
v
System orchestration does not belong to the LLM
|
| 9. Agent runtime platforms
v
The agent becomes a platform workload
Level 1: Claude Code
We stop moving code between chat and IDE.
The model gets the repository, shell and tools. It starts working in a loop:
inspect
-> act
-> observe result
-> decide what to do next
Level 2: Context engineering
Claude can already work in the repository, but it does not automatically know the project's rules.
We move repeated instructions from the conversation into the repository: CLAUDE.md, documentation, explicit testing and verification commands.
Level 3: Retrieval, RAG and MCP
The repository is only one fragment of a developer's world.
Claude sometimes needs PR history, CI logs, documentation, ADRs, runbooks or the current state of a service.
We stop being the manual interface between AI and those systems.
Level 4: Skills, Hooks and Permissions
If you regularly explain the same method of work to Claude, it is no longer a prompt.
It is a repeatable way of working.
We write it as a skill, move mechanical steps to hooks and move critical boundaries to permissions.
Level 5: Subagents
One context should not do everything.
Implementation, independent review, test analysis or research can get separate contexts and separate responsibilities.
Level 6: Dynamic Workflows
An LLM is not reliable workflow memory.
If you said at the beginning of an hour-long task "at the end, make sure to do X", correctness of the SDLC should not depend on the model remembering that after dozens of tool calls.
The workflow leaves the context and becomes an executable structure.
Level 7: Managed Agents
So far everything could run in your terminal.
At this level we take a task that you would normally run through Claude Code in a repository and run it outside the laptop, as a session in a managed environment.
This is the moment where AI starts becoming not only a personal developer tool, but an element of the SDLC.
Level 8: Beyond Dynamic Workflows
Claude does not need to own the whole orchestration.
If a workflow starts to include webhooks, queues, long waits, approvals, retries and system state, part of the responsibility should move to an external orchestrator.
Level 9: Agent runtime platforms
Managed Agents are not always the final level.
In a larger organization, an agent can become an ordinary platform workload that needs to fit IAM, networking, secrets, observability, governance and deployment standards.
End goal
The point is not for every team to end up with a dozen agents.
The point is a conscious split of responsibilities:
Claude
= reasoning
context
= knowledge needed to make decisions
tools
= ability to act
skills
= repeatable know-how
subagents
= separate contexts for separate tasks
workflow
= order and conditions that the LLM should not track from memory
environment
= the place where the agent actually performs the work
orchestrator
= durable state, retries, waits, webhooks and system integrations
agent runtime
= hosting, identity, scaling, observability and governance for agents
We start with the simplest upgrade: stop carrying code to AI and let AI enter the repository.