Skip to content
X

Level 5: Architect — Multi-step Systems and Sub-agents

At Level 4 you learned to design memory. The next step is delegating tasks that involve multiple steps to Claude all at once. The Level 5 approach is completing “spec review → implementation → testing → PR creation” in a single prompt.

Target audience: Anyone who understands Context Engineering and wants to delegate multi-step tasks to Claude all at once.

Estimated learning time: Read 25min + Practice 40min


A multi-step workflow means delegating a task that involves multiple steps with a single prompt, rather than giving sequential instructions.

Sequential instructions (Level 1–4 approach)

Section titled “Sequential instructions (Level 1–4 approach)”
> Organize the requirements for the authentication feature
→ Organizes them

> Implement a POST /auth/login that issues a JWT token
→ Implements it

> Write tests
→ Writes them

> Run the tests
→ Runs them

> Create a PR
→ Creates it

This requires 5 back-and-forth exchanges.

Single-prompt delegation (Level 5 approach)

Section titled “Single-prompt delegation (Level 5 approach)”
> Please execute the following in order:
>
> 1. Implement a POST /auth/login endpoint in src/routes/auth.py
>    (authenticate with email + password and return a JWT token)
> 2. Write tests in tests/test_auth.py and run them with pytest
> 3. Once all tests pass, git commit and create a PR
>    (branch name: feature/auth-login)
>
> If a completion condition cannot be met, stop at that point and report.

Claude autonomously executes each step, and a PR is created at the end.

When handing off a task in a single prompt, specifying these 3 elements lets Claude proceed without hesitation:

ElementContentExample
GoalWhat to ultimately achieve”Implement JWT authentication and create a PR”
ConstraintsLibraries to use · file locations · conventions”Use python-jose · always write type hints”
Completion conditionWhat counts as done”All tests pass”

Before a complex task, it’s safer to have Claude draw up the plan first:

> Please just create a plan first. Do not implement yet.
>
> Please create a plan for implementing JWT authentication.
> Include the libraries to use, files to implement, and testing approach.

Example plan output from Claude:

## Implementation Plan: JWT Authentication

### Libraries to Use
- python-jose: JWT token generation and verification
- passlib: Password hashing

### Files to Implement
- src/routes/auth.py — POST /auth/login endpoint
- src/services/auth_service.py — Authentication logic
- src/schemas/auth.py — Pydantic schemas

### Testing Approach
- Happy path: Correct email + password returns 200 + token
- Error case: Non-existent email returns 401
- Error case: Wrong password returns 401

Shall I proceed with this plan?

Responding “Looks good, please implement it” starts the implementation. Reviewing up front lets you correct any misalignment before implementation begins.

Sub-agents are a mechanism where the main Claude instance launches separate Claude instances to handle multiple tasks in parallel.

If you ask research questions one by one, you wait for the first answer before asking the second — that’s serial processing. With sub-agents, multiple investigations run simultaneously and are reported back together.

> Please investigate the following in parallel:
>
> 1. The current authentication implementation in this repository (if any)
> 2. Whether python-jose and passlib are installed in requirements.txt
> 3. The patterns used in existing test files (how fixtures are used, etc.)
>
> After the investigation is complete, summarize the implementation approach for JWT authentication.

Three investigations run in parallel and the results are reported together. This is significantly faster than asking sequentially, and Claude proposes the implementation approach after having understood the existing code patterns.


If you want to learn by doing, check out the tutorial.

Hands-on tutorial for this level →

Level 6: Systems Builder — Headless Automation and Pipelines