Aren’t you tired of new model appearing every day?
I used to think the model was the most important part. Now I’m convinced it’s the setup around it. It’s harness, it determines what the model can see, how it receives a task, where it does the work, and how the result is checked.
The popular harness is OpenClaw, 389k stars on GitHub. You’ve probably heard of it.
In this issue: 5 harness ideas from big boys and how to copy them
Devin: give AI a safe space to operate
OpenAI: write the instructions for each topic
Claude: load the right page only when it’s needed
GitHub Copilot: create a ticket
Cursor: ask AI to check the work before you see it
First, some context for those who are interested
Boring but interesting (skip to the ideas if you like)
OpenAI says what slows companies is how agents are built and run rather than model itself. Anthropic’s experiments with long-running agents found that even top AI, with simple prompt, fail to build a production-quality app, it improves dramatically when harness introduced though.
There’s a chart from AGI bench and as you can see Astra improved for 10% just running with harness.
There is also beautiful research by scale AI locked the model on four tasks and let another AI rewrite only the harness. The best attempts gained about 60% up improvement.
Five ideas to copy this weekend
Five of the biggest AI tools are built around ideas small and simple enough to copy in a weekend.
Together they form a sequence:
Give AI a safe space to operate → write the instructions → load the right page → create a ticket → check its work.
You do not need to be a programmer to follow it.
1. Devin: give AI a safe space to operate
AI that can act can also do damage: the wrong file deleted, the wrong instructions saved and followed. So, give it a safe space to operate.
Devin makes that space as-is: every session runs inside its own computer, with a browser and code editor.
Anthropic’s Managed Agents split the brain (AI and its harness) from the claws (safe computers and tools that do the actions). OpenAI’s kit for building agents, the Agents SDK follows the same approach.
Idea: Give each AI project one bounded safe space to operate in. (And keep a backup copy of the most important files)
How to copy it without dedicated computer:
Make one folder for the project.
Save the note below in the folder. The concept is similar to CLAUDE.MD
The note looks like this:
For this project, you operate only in the project folder, only with the assets below, and only inside the boundaries below:
INPUTS
[list the files, documents or sources you may use]
TOOLS
[list the tools you may use]
OUTPUT
[where the finished work should go]
BOUNDARIES
- Do not modify anything outside this folder.
- Ask before using a tool or source that is not listed above.
- Never invent facts, names, numbers or links.
- Never send, publish, buy, delete or approve anything without me.
- [add your own boundaries]
INDEX
Longer rules live on these pages; open one, or ask me for it, when the job needs it:
- [Topic]: the [name] page.2. OpenAI Codex: write the instructions for each topic
Before the AI starts working, give it written instructions about how work gets done for each pillar you are working on.
Codex and a handful of other tools turned that into a file called AGENTS.md, md file that tells an agent the rules: the house style, the commands, the limits, the tests etc. The concept also similar to SKILLS description from next idea.
Idea: For each task, write instructions once.
How to copy it:
Open a blank document in the project folder from idea 1, one set of instructions for each topic (research rules, slide rules, email tone, etc.).
One page per topic.
Write only rules that are general for that topic.
The instructions look like this:
[Title, e.g. research]
Every time, in this order:
- [First step: what to open or pull, and from where]
- [Second step: what to draft, and from what starting point]
- [When it must be ready for me]
House style:
- [How long: one page, 200 words, five slides]
- [Spelling and names: British or US; how we write the company and product names]
- [How numbers, dates and titles appear]
Facts come from:
- [The one or two sources that count for this task]
- [Which source wins when they disagree]
Good looks like:
- [One finished example to match, and where to find it]
Never:
- [What must not be sent, changed or decided without approval]
Who signs off:
- [Who approves which part, and how to mark the parts they have not seen yet]3. Claude Code: load the right page only when needed
The instructions create a new problem: AI has to read all of them to find the one it needs.
Claude Code’s answer with progressive disclosure: show the AI a little first, and let it open more only when agent needs it. Instead of reading every rule up front, the AI reads a short list of what exists.
Anthropic’s Agent Skills is built upon this principle: folders of instructions for particular kinds of work. At startup, Claude sees each skill’s name and one-line description. It reads the full instructions only if the current job needs that skill. Google has since adopted the same format in its Agent Development Kit.
Idea: Build an index of the pages in the instructions, and let the AI open a page only when it needs one.
How-to:
Give every page a name and one line at the top saying when to use it.
List the pages under INDEX in the note from idea 1, one line each.
If the AI can see the folder, add one line telling it to check for new pages at the start of every session and add them to the index itself.
A filled-in index looks like this:
INDEX
Longer rules live on these pages; open one, or ask me for it, when the job needs it:
- Research and fact checks: the research page.
- Slides: the slides page.
- Email: the email tone page.4. GitHub Copilot: create a ticket
Once the AI knows the rules and has the right page open, the question is how you hand over work.
GitHub now lets you assign a ticket to Agent same as you assign it to teammate.
Idea: Write tickets that describe what you want finished.
From product management we know a basic template for a good ticket:
Job: what needs to exist at the end.
Context: what it needs to know.
Constraints: what it must not do.
Done when: how you will decide it is finished.
How to copy it:
Add the ticket template below as a page with your other instructions, and list it in the index.
In the note from idea 1, add a rule: turn every request I give you into a ticket in this shape.
Add: ask me your questions and get my approval on the plan before you start.
A ticket looks like this:
ticket
Use this page when I hand you a job.
Treat this as an assigned job.
JOB
[What needs to exist when you are finished]
CONTEXT
[What you need to know]
CONSTRAINTS
[What you must not change, assume, send or decide]
DONE WHEN
[Concrete conditions the result must satisfy]
Start by showing me your plan.
After I approve the plan, do the work.
Do not use the chat itself as the finished work.
Put important decisions and results into the work itself.
Before you show me the result, run the quality gate.
[For risky jobs: stop and show me before each step, not only at the plan.]5. Cursor: ask AI to check the work before you
Once an AI has a safe space to operate and a ticket to work from, a new problem becomes more important:
Who checks the work?
In its shadow workspace, Cursor test AI’s edits in a hidden window, separate from your actual files. Automatic error-checkers run on those edits and send the errors back to the AI, which fixes them before anything touches your work. Cursor says letting an AI see the errors in its own edits is one of the biggest improvements you can make to the code.
In the long-running agent experiments mentioned above, Anthropic found the same thing: Claude often marked features complete without properly testing them, and giving the agent browser tools and telling it to test the app before user.
Idea: Put a quality gate between the AI’s output and your attention.
One rule I add myself: the agent may not change a file until it has written down the goal, how the result will be judged, and the steps.
How to copy it:
Add a page bellow to instructions
Add rule to operating space to run quality gate after task completed
Ask AI to show the gate note with task completion message
The gate looks like:
Quality gate
Do not show me the result yet. Run the quality gate first, layer by layer.
Layer 1, check yourself:
- Does the result do the job in the ticket? Where it does not, say where.
- List anything you made up or guessed.
- Give your confidence, 0 to 100, and the reason.
Layer 2, check against the ticket, the instructions and the inputs:
- Every done-when condition in the ticket and in the instructions is met, and no constraint is broken.
- Every number that can be recalculated is recalculated.
- Names, dates and facts match the inputs.
- No section is missing, and the house style is followed.
- The result matches the example under Good looks like in the instructions.
Layer 3, check against the world, as far as your tools reach:
- Open every link. Compare every number with its original source.
- Run whatever can be run: the spreadsheet, the formula.
- Mark what only user can verify, such as whether the audience understands it.
Fix what can be fixed. Then show me:
- the result;
- what failed a check and was fixed;
- which parts each approver has not yet seen;
- what still needs user.Final thoughts
Now you have your personal harness set up: the AI works in the folder and reads the instructions and the pages kept there; the ticket hands it work, and the gate checks that work.
Models keep getting better and cheaper. Because the system around them is already set, each new model gives you more and more power.
I’m opening six 1:1 AI working sessions
Bring one real problem with your AI setup. We’ll work through it together, with your hands on the keyboard throughout.
You’ll get:
A 90-minute working session
A written action plan with recommended changes and relevant resources
Seven days to ask follow-up questions by email or chat
You’ll leave with a clear plan, practical next steps, and a setup you understand well enough to keep improving yourself.
€250 per session
I’m limiting this to six sessions so I can give each person a full week of follow-up support.
Thanks for sharing!