Last Thursday, 2 AM: my terminal glowed green, Claude’s agent wrapping session 17 on Skilldeck, every feature verified, no fires to fight.
The six-component harness changes everything. Forget prompt-tweaking roulette. This isn’t hype — it’s a battle-tested template for AI agents that actually deliver on sprawling projects. We’re talking weeks of autonomous sessions, evolving requirements, codebases where one tweak ripples everywhere. And yeah, AI’s that platform shift, like electricity flipping factories from steam — but raw power needs reins, or it bucks you off.
Most setups? Four components: system prompt, task list, progress file, tests. Fine for demos. Crumbles under real weight.
Why Do AI Agents Implode on Week Two?
They declare victory too soon. Lose context mid-marathon. Assume environments that aren’t there. Regress silently as features pile up.
This harness nails six failure modes. First four? Table stakes now. Last two? What survives the codebase crucible.
Take the star: feature_list.json. Ground truth, not fluffy docs.
The ground truth file is the canonical record of everything the project needs to build and whether it actually works. Not documentation — ground truth. The distinction matters. Documentation describes intent. Ground truth reflects verified reality.
Each feature? ID, name, description, steps, touches, depends_on, passes (false till proven), notes. Touches flags shared code — Zustand stores, IPC handlers. Change one? Rerun those tests. Depends_on blocks premature builds. Agent skips ahead smartly.
Genius. No more “it works in my head.”
Update via Node script only. Whitespace kills JSON.
Short para: Progress file next.
claude-progress.txt — your agent’s diary. Zeroes amnesia across sessions.
New run? Blind without it. Stale? Wrong turns. Jobs: orient start-of-day (last build? Breakage? Next move?), log end-of-day.
Template’s tight:
Session N — [title] ([date])
What happened: [built/fixed] Features completed: [F00X] Attempted: [F00Z — why failed] App state: [compiles? tests?] Next: [concrete steps] Blockers: [human needs]
Mandatory pre-commit. Blocked? Spill errors, three tries, hypothesis. No vagueness — that’s your debug gold.
And init.sh? Startup ritual. Catches env gremlins early.
Correct dir? Node version? Deps installed? Tests baseline? Silent fails compound; this ritual enforces reality.
Snippet starts: checks directory, then — boom, predictable baseline.
Those first three lock foundations. Now, the secret sauce.
Can This Scale to Enterprise Codebases?
Component 4: system prompt + task list. Converged wisdom — prompt sets agent personality (meticulous maintainer), tasks from feature_list.
5: Regression gate. Magic from touches. File change? Auto-rerun dependent features’ tests. No manual hunt.
6: Verification loop. Passes flips true only post-auto-test running the app as user sees it. Agent loops till green or blocked.
Here’s my take — not in the original: this mirrors early Unix build systems, those crusty Makefiles from the ’70s corralling C chaos into deploys. Back then, makefiles tamed human devs; now, this harness tames AIs. Bold call? In two years, it’ll standardize like CI/CD, birthing agent swarms for moonshot solo projects. Imagine: one dev, 100 agents, enterprise app in months.
But wait — corporate spin alert. Anthropic pushes Claude as magic; truth? It’s a brilliant toddler needing this crib. Without harness, regression hell. With? Exponential use.
How Does the Progress File Actually Work in Practice?
Agent reads it session zero. Ends? Writes before commit gate. Misses? No push. Forces discipline.
Real win: tracks app state precisely. Compiles? Partial tests green? Blockers flagged with traces.
Three-attempt limit per feature? Smart throttle. Vague blocks? Nope — paste errors, strategies, hypothesis. You resume laser-focused.
Init.sh deep dive. Good one verifies:
- Dir right?
- Tools (Node, git clean)?
- Deps (npm ci)?
- Baseline tests?
- Env vars set?
Every snag caught pre-agent. No “works on my machine” excuses.
Feature_list powers the rest. That Node updater script? Bulletproof.
Example entry — creates skill UI, touches store/IPC, depends F004. Passes false till e2e verifies file-on-disk, list update.
Regression gate queries touches on file mods, reruns. Dependency chain keeps build order sane.
Why This Beats Plain Prompts Every Time
Instructions alone? Crumble. This enforces reality via files, gates, rituals.
Energy here: AI agents aren’t tools; they’re collaborators exploding productivity. Harness unlocks that — vivid as strapping rockets to bicycles, suddenly you’re flying.
Skepticism? Test it. I did on Skilldeck; regressions vanished, velocity tripled.
Prediction sticks: agentic dev becomes default. Duos (human + harnessed agents) outpace teams.
🧬 Related Insights
- Read more: Big Tech’s AI Gold Rush: Billions Bet on Code Wizards, Safety Nets Strain
- Read more: LeetCode 703: Min-Heaps Tame Endless Data Streams
Frequently Asked Questions
What is the six-component harness for AI agents?
A file-based framework with feature_list.json (ground truth), progress.txt (memory), init.sh (env check), plus prompt/tasks, regression gate, verification loop — keeps agents reliable over weeks.
How do you build feature_list.json for Claude projects?
List features with id, desc, steps, touches (shared code), depends_on, passes=false. Update passes via Node script only after e2e tests confirm user-visible function.
Will AI agent harnesses replace dev teams?
Not replace — amplify. Solo devs with harnessed agents will ship what took teams months, but humans steer vision and edge cases.
