Most people use AI agents like a chatbot. One prompt, one response, repeat. That's not agentic. That's texting.
The real shift happens when you stop treating your agent like a conversation partner and start treating it like a machine. You give it a batch of work, it goes to town, comes back, and you review. I call this "printing." You're not prompting anymore. You're operating a printing press.
Here's how I set mine up.
Step 0: Self-Learning
Before you give your agent any real work, give it a memory.
Open Claude Code in your repo and tell it this: "Create a skill called self-learning, where you document every mistake you make and how you solved it, along with any other important knowledge. Reference this file while you work."
That's it. One sentence. Now your agent gets better every time it screws up. It's reinforcement learning with no infrastructure. Just a markdown file and a habit.
Step 1: Feed It a Batch
Here's what a real batch looks like for me.
I have a list of bugs and changes for one of my projects. I give Claude Code this:
"Here is a list of bugs/changes. Take the repo, investigate them yourself using sub-agents, and write Linear tickets with bug description, proposed fix and thoughts. Once you finish, sort the tasks into buckets grouped by similar tasks which are best performed by a single agent on a single branch. Create sub-agents to perform the work, make sure they use worktrees, then merge their branches into a release candidate. Once done, wait for me."
Read that again. I'm not asking it to fix one bug. I'm asking it to triage, plan, parallelize, execute, and package a release. That's a full work day of output from a single prompt.
Step 2: Make It Test Itself
When it comes back with the work done, I tell it:
"Good job. Now open your browser, go ticket by ticket and verify completion."
This is the loop. The agent does the work, then checks its own work. For this to function, you need to give it the tools. I use Playwright MCP so it can actually open a browser and interact with the app. It took me about a day to teach it how to use the platform. I explained how to navigate, what to click, what to look for.
Then I told it to make a skill out of that knowledge so it's reusable. Next time it tests, it already knows how.
Step 3: Review and Reject
Here's where the human stays in the loop.
After the agent finishes its batch and tests itself, I go through everything manually. Whatever doesn't pass, I reject. I tell it what went wrong and why.
"You did that wrong. You should have done this other thing."
The agent takes that feedback, fixes the work, and (because of the self-learning skill) logs the lesson. It won't make that mistake the same way again.
This is the printing press pattern: batch in, work out, reject the bad prints, run it again.
Step 4: Build Its Knowledge Base
Agents are smart but ignorant. They know how to code but they don't know your codebase. You need to fix that.
Tell it: "Review this repo, in depth, feature by feature, and create full and detailed documentation in a docs folder. This documentation will be used by AI coding agents to write features, so be precise. Once you're done, create a skill to ensure that all agents that work on features also update the relevant documentation as they go."
Now every agent that touches your code has context, and the docs stay current automatically.
The Pattern
The whole system is five pieces:
- Self-learning. The agent logs mistakes and references them.
- Batch work. You give it a pile of tasks, not one at a time.
- Self-testing. The agent verifies its own output using real tools.
- Human review. You reject what's wrong, the agent learns from it.
- Knowledge retention. Every correction becomes a skill. Every feature gets documented.
You're not pair programming anymore. You're running a production line. The agent does the volume, you do the quality control.
Stop prompting. Start printing.
