Four Concepts You Need to Work with AI Agents

Back in July 2025, I started using Claude Code. I wrote about prompts being the new source code, about workflows and saving AI outputs. It felt like the beginning of something.

A lot has changed since then. Agents are everywhere now — it's the only thing dev communities are talking about. And honestly? It can feel overwhelming. The FOMO is real. So is the impostor syndrome. Everyone seems to be shipping with agents while you're still figuring out the basics.

I've been using agents for seven months now. Tools changed, models improved, workflows evolved. But looking back, these four concepts are what actually made the difference. If you're just getting started — or feel lost in the noise — focus here.

1. Feedback Loops — The Foundation of Everything

What it is: The description of how to test what you want the agent to do. Not just what to build — how to verify it works.

For example, if you're working on a payment feature:

I need to implement an invoice after making a payment. The invoice should contain the amount, source, and destination. Should be a PDF and needs to be saved in the invoices bucket. Implement and test it by making a curl to the endpoint and check that the file is in the bucket.

That last sentence is the feedback loop. Without it, the agent builds something and hopes it works. With it, the agent builds, tests, and knows if it's done.

Why it matters now: This is how agents work. They try, check, adjust, repeat until done.

But here's the thing — it's also how we've always worked. TDD is a feedback loop. CI/CD is a feedback loop. Code reviews are feedback loops. Agents didn't invent this. They just run the loop faster.

But here's what most people miss: you need to include the feedback loop in the prompt. Effective use of agents is not just telling them what you want done. It's also telling them how to check that it's done. That's the goal.

If you're working in plan mode, your tasks should include this in the acceptance criteria.

❌ Implement the login form — That's incomplete.

✅ Implement the login form, then open the browser, test with valid and invalid credentials, verify error messages show correctly saying 'Invalid credentials, try again' — That's a feedback loop built into the task.

The key insight: Clear success criteria. A way to check the work. Iteration until it passes. That's it. The developers who work well with agents are the ones who define tight feedback loops.

What makes a good feedback loop:

  • Clear definition of "done"
  • Fast way to check pass/fail (tests, linters, type checks)
  • Small iterations (not "build the whole feature" — one piece at a time)
  • Reflection after each cycle (what did I learn?)

Start here: You already know this. You've been doing it. Every unit test, every conversation with Product team about how things should work lead to this moment. Now apply it to how you work with agents.

Don't assume. Spell it out. The clearer your feedback loop, the better the agent performs.

Resources:

2. AGENTS.md — Give Your Agent Context

What it is: A markdown file in your project that AI agents read automatically. It tells them how your project works — conventions, commands, patterns, gotchas.

Why it matters now: Agents are like a stateless REST API. Every request starts fresh — no memory of what came before. Without context, they guess. Sometimes they guess wrong. Like when your partner expects you read their mind and you reply that you don't do that, you need clear instructions. Exactly like that. Wait, it's just me? XD

AGENTS.md (or CLAUDE.md for Claude Code) is how you pass the initial context. It gives them what they need to work effectively in your codebase. It must be short and focused on the essentials. It must work as a tree of knowledge for the agent to navigate your project. If you want to describe the architecture, you can put a reference to the ARCHITECTURE.md file in your project. Let the agent do a progressive disclosure of information. Don't dump everything in one file.

The key insight: There are two levels.

The project level file lives in your repo — it's about this specific codebase. Conventions, commands, architecture, gotchas.

But there's also a global level file that lives in your home directory. This one is about your methodology. How you want agents to behave across all projects. Your workflow.

I use a "Plan → Design → Tasks → Work → Review → Compound → Ship" flow, and that's in my global file. Every agent I work with knows that's how I operate.

What to put in it:

  • How to run tests and type checks
  • Coding conventions your team follows
  • Important files and architecture patterns
  • Common mistakes to avoid

Resources:

3. Compound Engineering — Make Each Task Easier Than the Last

What it is: A workflow where you document what you learn after each task. Bugs found, patterns discovered, gotchas identified. That knowledge feeds into the next task, making it faster and better.

Why it matters now: Most people use agents for one-off tasks. They don't capture what was learned. Each new task starts from scratch.

Compound Engineering flips that — each task makes the next one easier because the system learns.

The key insight: It's a learning loop.

Feedback loops help you pass the current task. Learning loops help you pass future tasks better.

Try, check, reflect, document, repeat. The agent gets smarter about your codebase over time. So do you.

How it works:

  1. Agent completes a task
  2. You review what worked and what didn't
  3. You document learnings (in AGENTS.md, progress files, or commit messages)
  4. Next task benefits from that knowledge

Resources:

4. Ralph Wiggum — Autonomous Loops Until Done

What it is: A pattern (and open-source tool) that runs an AI agent in a loop until all tasks are complete. Each iteration starts with a fresh context window. Memory persists through git commits, a progress file, and a task list.

Why it matters now: You don't have to babysit agents for every step. Define what "done" looks like, break it into small tasks, and let the agent iterate until everything passes. It's feedback loops, automated.

The key insight: Each iteration, the agent tries, checks its work, and adjusts. It's the same loop we use in TDD. Write a test, fail, fix, pass. Ralph automates that cycle for agents, but again, feedback loops are key here too. If you write a bad unit tests, it will pass but the behavior will be not well implemented. If you do the same with the feedback loop, the agent will write code that doesn't meet your expectations but it will pass the checks. So you need to make sure your feedback loops are tight and effective.

How it works:

  1. You define tasks in a prd.json file
  2. Ralph picks the next incomplete task
  3. Agent implements it and runs checks
  4. If checks pass, it commits and marks the task done
  5. The agent instance dies
  6. A new agent instance with a clean context window is created
  7. New agent instance picks the next task
  8. Repeat until all tasks complete

Resources:

These four concepts are your foundation. Master them and you'll be ahead of most developers still figuring this out.

But here's what I really want to say: this is the moment.

I feel like I'm back in college — devouring everything I can about how things are built. Back then it was stories about Linus creating Linux in his dorm, or how Dell started from a garage. Now it's reading about how someone built an autonomous agent over a weekend, or how a solo dev shipped a product that would've taken a team of ten.

The stories are everywhere. Filter out the hype and the self-promotion. Find the builders who share what they actually learned. Read their journeys from start to finish. That's where the real lessons are.

Here's one I read this week: Mario Zechner's "What I learned building an opinionated and minimal coding agent". He explains why he built his own agent instead of using what's out there, and every decision he made along the way. Read it from start to finish. That's the kind of content that makes you better.

We're living through something big.

AI will not replace developers, it's like having bionic legs. You now don't need to worry about if your legs will be strong enough to run a marathon, you just need to think on how it's the best approach, the right strategy, the best way to use them to finish the race first. You need to focus on be the command of the starship, let the agents be your crew.