How to Build Self-Improving Coding Agents, Part 3: Turning Memory and Skills into Practice
Alternatively titled: How Markdown, skills, and repo memory combine to make agents feel like teammates.
Hello fellow datanistas!
Ever find yourself explaining the same thing to your coding agent over and over? I’ve been there. It’s a sign that something in your workflow wants to be systematized—and that’s where the real compounding value starts.
In this post, I’m sharing how to move beyond ad hoc prompting and start building self-improving coding agents—by combining repository memory and reusable skills into a practice that actually evolves with you.
Let’s be honest: most of us start with agents by just typing prompts in chat, hoping for magic. But if you want your agent to become more than a chat box—if you want it to feel like a teammate—you need a system for memory and skills that grows over time.
Here’s the maturity model I’ve been using:
Stage 0: Ad hoc prompting — You keep re-explaining things. It works, but it doesn’t compound.
Stage 1: Repo-local memory — Add AGENTS.md to capture repo-specific rules, navigation, and guardrails. Now your agent knows the lay of the land.
Stage 2: Global personal skills — When a workflow repeats, promote it to a global skill. Tools like `skill-creator`, `openskills`, and `agents-md-improver` help you bootstrap this.
Stage 3: Shared skills — If your team keeps repeating a workflow, promote it to a shared skill. But don’t start here—let pain guide your promotions.
The trick is to watch what your agent does in practice. When it takes a weird path or misses something obvious, ask: is this a repo rule (AGENTS.md) or a repeatable procedure (skill)?
What’s wild is that Markdown is becoming executable. When your agent can run tool calls, a SKILL.md isn’t just documentation—it’s a playbook the agent can run: searches, edits, tests, you name it. The agent loads skills on demand, so you can write instructions at the level you actually think about them, and let the agent handle the clerical work.
The real meta skill here is metacognition: noticing what you do repeatedly, and deciding what should be systematized. That’s how you build a compounding loop—your agent handles more of the grunt work, and you get to focus on judgment and design.
This isn’t just about coding. Once your agent can run commands and manipulate files, the surface area expands to almost anything intellectual—writing, release notes, even structuring messy notes. The label “coding tool” is starting to feel more like marketing than reality.
The combination of repository memory and reusable skills turns your agent from a chat box into a true teammate—one that learns from your workflow and grows with you.
How are you currently using agents in your workflow? What’s the biggest pain point you wish you could automate or systematize?
If you want the full breakdown (including concrete tools and decision criteria), check out the full post: How to Build Self-Improving Coding Agents: Part 3. If you found this useful, feel free to share or subscribe for more.
Happy Coding,
Eric