The Design Flow

You now know what each layer of an agent’s instructions is for and how to write it well. The remaining question is: where do you start?

There are two approaches. Both lead to the same place — a well-structured agent with lean instructions, focused skills, and intentional proactive triggers. They just get there differently.

Approach 1: Layer by layer

Start from the top and work down. Each step builds on the last.

1. Start with identity. 2–3 sentences. What way of thinking should this agent embody? Anchor to a known reference.
2. Define context. Resource map, user information, domain background. What does this agent need to know about its environment?
3. Write lean instructions. Standing duties, operational norms, rules of engagement. Only what applies to every interaction.
4. Extract skills. Pull out any procedures that only apply to specific tasks. Each one gets a clear title and description.
5. Set up schedules. Any tasks that need to happen at specific, recurring times? Write the schedule message — nudge, full task, or skill reference.
6. Consider a heartbeat. Does the agent need ambient awareness between conversations? If you cannot clearly describe what it should watch for, skip it.

This approach works well when you have a clear picture of the agent’s role from the start. You are making deliberate decisions at each layer.

Approach 2: Dump and extract

An alternative that is often more natural — especially when you have a rough idea of what you want but have not yet thought through the structure.

1. Write everything. Put everything you want the agent to know and do in one big block. Do not worry about structure — just get it all out.
2. Pull the way of thinking out → Identity. Find the sentences that describe who this agent is and how it thinks. Extract them. Apply the no-verbs test.
3. Pull environmental knowledge out → Context. Find the facts about the world — what tools exist, where files are, who the users are. Extract them.
4. Extract step-by-step procedures → Skills. Anything that reads like a playbook or manual — a series of steps for a specific task — becomes a skill.
5. Extract time-triggered tasks → Schedules. Anything that says “every morning” or “once a week” becomes a schedule.
6. What is left → Instructions. The standing norms, ongoing duties, and behavioral rules that apply every time. This should be the leanest section.
7. Consider a heartbeat. If the remaining instructions include ambient awareness concerns — “keep an eye on,” “notice when” — decide whether a heartbeat is the right mechanism.

This approach works well when you are starting from a messy brief, an existing document, or a conversation where someone described what they want. It turns unstructured intent into structured design.

Common anti-patterns

As you design agents, watch for these:

Anti-pattern	Symptom	Fix
Everything in one prompt	System prompt reads like a manual — thousands of words, hard to debug	Separate into identity, context, instructions; extract skills
Identity doing too much	Identity has verbs and procedures	Apply the no-verbs test; extract to instructions
Long instructions	Instructions read like a playbook with step-by-step procedures	Extract procedures to skills
No initiative	Agent is purely reactive — only answers questions	Add ongoing duties to instructions
Procedures in schedule messages	Schedule messages are paragraphs long, duplicating content available elsewhere	Move shared procedures to skills; nudge toward them
Heartbeat without instructions	Agent checks in every interval but has nothing to check	Define what it cares about in instructions first
Heartbeat as task scheduler	Heartbeat describes specific tasks to execute	Use schedules for specific tasks; heartbeat is for awareness

Iteration is the real process

No agent design is right on the first attempt. The system prompt needs tuning. The skills need refining. The heartbeat needs adjusting as you discover how the agent behaves in different situations.

Both approaches — layer by layer and dump and extract — are starting points. The real design process is what happens after: observing how the agent behaves, identifying where it falls short, and adjusting the instructions. Move content between layers. Sharpen skill descriptions. Rewrite schedule messages. Simplify the heartbeat.

The concepts in this guide give you a clear vocabulary for those adjustments. When something is wrong, you can name where the problem is — and that makes it fixable.