Compounding agent improvement
The most valuable "skill" you can develop is not a specific file format; it is the habit of metacognition. You must observe your own work and ask: "What am I doing repeatedly that should be systematized for an agent?"
The maturity model
I've observed that the practice of building self-improving agents tends to follow a four-stage progression. Use these stages to measure your own journey.
Stage 0: Ad hoc prompting
You find yourself re-explaining the same context or preferences in every new chat session. It works, but the effort is lost the moment the chat window closes.
Stage 1: Repo-local memory
You bootstrap an AGENTS.md file in your repository. The agent now understands where things live and which local norms to respect. You no longer repeat yourself within a single project.
Stage 2: Global personal skills
You identify patterns that span multiple projects (like drafting release notes or setting up environments) and promote them into global skills on your machine. You now carry your personal playbooks with you from repo to repo.
Stage 3: Shared team skills
You publish your skills to a central location where your teammates can install and contribute to them. Your individual expertise scales to the whole organization.
Decision rule: AGENTS.md vs. Skills
It can be tempting to put everything into AGENTS.md, but that leads to context bloat. Here is how I decide where a piece of information belongs.
| Situation | Where to put it? | Why? |
|---|---|---|
"Always use pathlib.Path over os.path" |
AGENTS.md |
Repository-wide invariant |
| "Draft a release memo for MS Teams" | Skill |
Named procedure with output contract |
"The src/ folder is for library code" |
AGENTS.md |
Navigation help |
| "Debug a failed GitHub CI run" | Skill |
Multi-step playbook |
The approach is straightforward: if it is a constraint or navigation hint, it belongs in AGENTS.md. If it is a repeatable procedure, it belongs in a Skill.
Markdown as an executable language
One reason this approach works is that natural language is becoming executable. When an agent has access to shell tools and file manipulation, a well-written Markdown file is essentially an executable script.
By being linguistically precise in your skills and AGENTS.md, you are not just writing "documentation" for a human to maybe read later. You are writing instructions that the agent can turn into grep searches, file reads, and surgical edits.
The metacognition habit
I strongly encourage you to do a weekly "repetitive task audit." Ask yourself:
- Did I explain repo structure to an agent more than once this week? (Add to
AGENTS.md) - Did I struggle to find a specific file neighbor? (Update the
AGENTS.mdcode map) - Did I write a similar summary or report more than once? (Create a Skill)
Where this is going
I buy the framing that these tools are "general agents" disguised as developer tools. Whether you use a terminal-based agent or an IDE-integrated one, the label "coding tool" is just the starting point.
In the future, we will see these agents move to the web, carrying their repository memory and skills with them. The goal is to move from a "chat box" to a teammate that starts every session exactly where you left off.
See this in action
The Automation philosophy is the engine behind this entire book. Building self-improving agents is the ultimate form of automation compound interest. You spend mental energy on design and judgment, while the agent handles the clerical execution.