explainx / blog
Boris Cherny from Anthropic reveals how engineers ship 8x more code by building iterative loops instead of single prompts. Learn harness engineering, the approach behind Claude authoring 80%+ of production code at Anthropic.
Jun 27, 2026
Plan Mode gives you a complete picture of what Claude intends to do — which files it will touch, why, and in what order — before a single character changes. Here is how to use it properly.
Jun 11, 2026
Claude Code exposes 90+ slash commands for setup, parallel agents, review, memory, and shipping. This is the complete reference: what each command does, when to use it, and how they fit a typical workflow.
Jun 9, 2026
Peter Steinberger's June 8 tweet—6.5M views—said stop prompting agents and start designing loops. This guide answers the thread's top question ("how do we do that?") with lineage, /loop examples, verification, and guardrails.
TL;DR: Single prompts are obsolete for serious software engineering. Anthropic's Boris Cherny explains that production AI coding requires harness engineering—building systems that run iterative loops where Claude observes, plans, acts, and reflects over hours or days. This approach helped Anthropic engineers ship 8x more code daily, with Claude authoring over 80% of merged production code by May 2026.
"You're not supposed to prompt Claude. You're supposed to build a system that prompts itself."
This statement from Boris Cherny, engineer at Anthropic, has sparked a fundamental rethinking of how developers should use AI coding assistants.
The problem with single prompts:
The solution: harness engineering—systems that autonomously prompt AI agents in iterative loops.
Harness engineering is the practice of building frameworks that orchestrate AI agents through repeated observe-plan-act-reflect cycles.
1. OBSERVE → Analyze current codebase, test results, error logs
2. PLAN → Determine next action based on observations
3. ACT → Execute code changes, run tests, make commits
4. REFLECT → Evaluate results, identify gaps, adjust strategy
5. REPEAT → Loop until task complete or timeout
This isn't a single prompt like "Add user authentication." It's a system that:
Traditional Single Prompt:
User: "Add JWT authentication to the API"
Claude: [Generates auth code in one file]
User: [Realizes it needs database migration, middleware, tests, docs]
User: "Now add the migration"
Claude: [Generates migration]
User: "Add middleware"
... 15 more manual prompts ...
Loop-Based Harness Engineering:
# Simplified harness pseudocode
task = "Add JWT authentication to the API"
max_turns = 50
context = CodebaseContext()
for turn in range(max_turns):
# OBSERVE
status = context.analyze_codebase()
test_results = context.run_tests()
# PLAN
plan = claude.plan_next_action(task, status, test_results)
# ACT
if plan.action == "modify_file":
context.edit_file(plan.file_path, plan.changes)
elif plan.action == "run_migration":
context.execute_migration(plan.migration_file)
elif plan.action == "write_tests":
context.create_test_file(plan.test_code)
# REFLECT
if plan.task_complete:
break
# Update context for next iteration
context.commit_changes(plan.commit_message)
Result: Claude autonomously:
All without human intervention beyond initial task specification.
By May 2026, Anthropic engineers using harness engineering:
Before (Single Prompts - Q1 2025):
After (Harness Engineering - Q2 2026):
Start with a basic observe-act loop for repetitive tasks:
// Example: Auto-fix linting errors
async function lintFixLoop(maxIterations = 5) {
for (let i = 0; i < maxIterations; i++) {
// OBSERVE
const lintResults = await runLinter();
if (lintResults.errors.length === 0) break;
// ACT
const fixes = await claude.generateFixes(lintResults);
await applyFixes(fixes);
// REFLECT
console.log(`Iteration ${i+1}: Fixed ${fixes.length} issues`);
}
}
Use cases: Linting fixes, test debugging, dependency updates
Add planning and task breakdown:
async function featureLoop(featureSpec: string) {
// PLAN
const tasks = await claude.breakdownFeature(featureSpec);
for (const task of tasks) {
// OBSERVE
const context = await analyzeCodebase();
// PLAN SUB-ACTIONS
const actions = await claude.planImplementation(task, context);
// ACT
for (const action of actions) {
await executeAction(action);
await runTests();
}
// REFLECT
const taskComplete = await claude.validateCompletion(task);
if (!taskComplete) {
tasks.push(await claude.identifyGaps(task));
}
}
}
Use cases: Feature implementation, refactoring, migration tasks
Full harness with error recovery, checkpoints, and human approval gates:
interface HarnessConfig {
task: string;
maxTurns: number;
checkpointInterval: number;
humanApprovalRequired: string[]; // e.g., ["database_migration", "api_breaking_change"]
}
async function autonomousHarness(config: HarnessConfig) {
let turn = 0;
let context = new ProjectContext();
while (turn < config.maxTurns) {
// OBSERVE
const status = await context.fullAnalysis();
// PLAN
const plan = await claude.strategicPlan(config.task, status, turn);
// HUMAN CHECKPOINT
if (config.humanApprovalRequired.includes(plan.actionType)) {
const approved = await requestHumanApproval(plan);
if (!approved) continue;
}
// ACT
try {
await executeActionSafely(plan.action);
} catch (error) {
// ERROR RECOVERY LOOP
const recovery = await claude.recoverFromError(error, context);
await (recovery.);
}
testResults = context.();
reflection = claude.(
config.,
status,
testResults,
turn
);
(reflection.) ;
(reflection.) {
(reflection.);
}
(turn % config. === ) {
context.();
}
turn++;
}
context.();
}
Use cases: Full feature development, complex refactors, multi-service changes
Boris Cherny highlighted a critical insight: 14% of developer productivity is lost to poorly structured CLAUDE.md files (or equivalent project context files).
Bad CLAUDE.md:
# My Project
This is a web app for users.
## Stack
- React
- Node
- Postgres
## Instructions
Be helpful!
Result: Claude wastes turns asking basic questions about:
Good CLAUDE.md for harness engineering:
# Project Context for AI Agents
## Architecture Map
- `/app/*` - Next.js App Router (React Server Components)
- `/lib/db/*` - Prisma ORM, PostgreSQL schemas
- `/lib/api/*` - tRPC API routes
- `/components/*` - React components (shadcn/ui + Tailwind)
## Code Style (CRITICAL - Follow Exactly)
- Server components by default; 'use client' only when needed
- Prefer server actions over API routes for mutations
- Database queries only in server components or server actions
- All async functions must handle errors with try-catch
- Use Zod for all input validation
## Testing Strategy
- Unit tests: Vitest for pure functions
- Integration tests: Playwright for user flows
- Run `pnpm test` before any commit
- Coverage requirement: 70%+
## Common Patterns
### Adding a new API endpoint
1. Define Zod schema in `/lib/schemas`
2. Create tRPC procedure in `/lib/api/routers`
3. Write integration test in `__tests__/api`
4. Update OpenAPI docs if public endpoint
### Database changes
1. Modify schema in `prisma/schema.prisma`
2. Run `pnpm db:migrate:dev` to create migration
3. Update seed data if needed
4. Test migration rollback works
## Deployment
- Production: Vercel (auto-deploy on main branch)
- Staging: Railway (auto-deploy on develop branch)
- Never commit secrets - use `.env.local` and Vercel env vars
## Business Context
- Users are B2B SaaS companies (SMB to mid-market)
Average deal size: $50K-200K/year
Security/compliance critical: SOC2, GDPR
Performance target: p95 page load < 2s
Impact: Reduces wasted turns by 60%, allows Claude to make informed decisions without asking.
Early adopters of harness engineering on Twitter report:
The community has created extensive guides:
By May 2026:
Not everyone is convinced. Critics raise valid concerns:
Poorly designed loops can:
Mitigation:
Designing effective harnesses isn't beginner-friendly:
Reality: This is a new skill set. Teams need training and iteration.
Bad fit for harness engineering:
Good fit:
Claude Code CLI (Anthropic)
/goal commandCursor AI (Anysphere)
Aider (Open Source)
LangGraph (LangChain)
AutoGPT
CrewAI
The shift from single prompts to iterative loops isn't limited to coding.
Emerging patterns across domains:
By 2027, every serious AI application will be loop-based, not prompt-based.
Single prompts will remain for:
But complex work—software, analysis, research, strategy—will all use harness engineering.
The developers shipping 8x more code aren't writing better prompts. They're building better systems.
The harness engineering mindset:
If you're still manually prompting Claude for every change, you're using a sports car as a bicycle.
The playbook:
By end of 2026, harness engineering will be a core skill for every software engineer—as fundamental as Git, testing, or code review.
The question isn't whether you'll adopt it. It's whether you'll be an early mover or late adapter.
Last updated: June 8, 2026 | Research sources: Boris Cherny (Anthropic), developer community reports, harness engineering tutorials, production deployment data