Boris Cherny, the head of Anthropic's Claude Code project, says the era of developers typing out every line is giving way to a new model where they instruct, supervise, and constrain AI agents that do the heavy lifting. In a detailed breakdown published by StartupHub.ai, Cherny argues that the core skill for engineers is no longer coding syntax but building a "harness" — a set of protocols, permissions, and tests that keep AI-driven development safe and productive. For Windows developers already juggling tools like Visual Studio, GitHub Copilot, and command-line agents, the message is clear: the harness is now part of your job.
What exactly is Cherny proposing?
Cherny's "harness" isn't a single product; it's a way of working. According to the StartupHub.ai summary and related materials, it includes:
- Project guidelines as living documents: Anthropic encourages teams to store instructions in repository files like
CLAUDE.md. These teach the AI about code style, architecture, rules, and commands. - Automated testing and validation: No AI-generated change should be merged without passing your existing test suite. The agent itself can run these tests, but the harness ensures they are mandatory.
- Strict permission boundaries: Limit what files an agent can touch, what commands it can run, and which systems it can access. The agent should operate with the least privilege necessary.
- Human review gates: For any change touching security, compliance, or production, require a human to sign off. The agent is a collaborator, not an autonomous decision-maker.
The idea is that an AI coding agent becomes more like a junior developer on your team: you give it context, break down tasks, and then review its pull request. The agent might experiment, run tests, and even revise its own code — but only within the harness. As Cherny told Fortune, he sometimes manages tens of thousands of agents at once, and the only way that works is with rigorous guardrails.
What does this mean for Windows users?
Windows developers aren't watching this from the sidelines. Many already use ChatGPT, Copilot, or Claude in their daily work. In VS Code, extensions like GitHub Copilot Chat allow conversational coding. Terminal-based agents like Claude Code (in WSL or directly on Windows) can read entire repos, spawn parallel tasks, and make multi-file changes.
If you're a solo developer or hobbyist, the impact is immediate: you can delegate boilerplate work, migrations, or bug investigations to an agent. But the harness means you need to be more deliberate about documenting your intentions. A CLAUDE.md in your repo is no longer just optional documentation; it's the operating manual for your AI assistant. Without it, the agent will make assumptions — and those assumptions can lead to messy or insecure code.
For enterprise teams, the implications run deeper. System administrators must consider how to provision and monitor agent accounts with the same rigor as human developers. Should the agent share your credentials? Probably not — it should have its own identity, scoped to its task. And every automated change should go through the same CI/CD checks you'd apply to a human contribution. Those checks should include static analysis, dependency scanning, and security reviews.
IT pros managing Windows environments may soon see requests from developers to allow AI tools with system-level access. That requires a new security checklist: isolated virtual environments, no persistent access to production systems, and logging of every action an agent takes. Windows Sandbox, Hyper-V VMs, and dev containers become essential parts of the harness.
How did we get here?
The journey from autocomplete to autonomous agents has been rapid. Just a few years ago, AI coding meant inline suggestions in VS Code. Then came chatbots that could explain code or generate functions. Now, tools like Claude Code, Cursor, and GitHub Copilot Workspace can execute multi-step plans: they read issues, search codebases, edit files, run commands, and open pull requests — all while you sip coffee.
Anthropic's path has been unique because of its emphasis on "safety and alignment." Cherny notes that years of alignment research have made it possible to keep models on task during sessions that can last weeks. That extended memory is what allows an agent to learn your project's conventions and avoid repeating mistakes. StartUpHub.ai's summary links this to better model memory and longer-running sessions. As first reported by Fortune, Cherny sees days where he manages tens of thousands of agents; that scale is possible only with agents that remember context across interactions.
The original source also references early prototypes where AI could use a computer to order a pizza. That seems trivial, but it was a proof of concept for tool use. Now, the tool is your entire development environment, and the outcomes matter a lot more. Claude Code can work asynchronously, with parallel agents handling different parts of a task — a workflow Anthropic itself has demonstrated in live coding sessions.
What should you do right now?
Whether you're an individual Windows coder or part of a team, here are actionable steps to build your own harness:
- Start a CLAUDE.md file (or equivalent for your tool). At minimum, it should include:
- Your project's build and test commands
- Code style conventions
- Architecture overview
- Key files and directories the agent should know about
- Rules the agent must always follow (e.g., "Never modify this config file") - Treat AI configuration as code. Review CLAUDE.md in pull requests, keep it versioned, and ensure it doesn't expose secrets or internal details you wouldn't share publicly. Remember, an agent with read access to your repo could leak these if prompted.
- Run agents in contained environments. Use Windows Sandbox, Hyper-V VMs, or dedicated dev containers. If an agent can install packages or run scripts, assume it could make a mess. Docker-based development environments are your friend.
- Enforce automated testing. The agent should not be able to mark a task as done without passing your existing test suite. Add tests that specifically verify the agent's changes are correct.
- Implement human sign-off. For any change that affects security, data handling, or production paths, require a human review. No bypass.
- Log everything. Agent interactions, commands executed, and files changed should be traceable. This is critical for debugging and compliance.
- Start small. Let the agent handle a non-critical bug fix or a dependency update. Use that experience to refine your harness before letting it loose on larger tasks.
For Windows-specific workflows, remember that many agents integrate with PowerShell and the Windows command line. If you're scripting administrative tasks, the same principles apply: define what the agent is allowed to do, test in a sandbox, and never grant unrestricted access to production systems.
Outlook
Cherny's vision isn't science fiction — it's partially here. Teams at Anthropic and elsewhere are already managing tens of thousands of AI agents in parallel. That scale won't happen overnight in a typical Windows shop, but the direction is set.
The role of "software engineer" is broadening to include AI orchestration. The craft won't disappear, but the daily activities will shift from writing loops and conditionals to defining success criteria, curating context, and verifying complex outputs. The harness is the new keyboard.
For Windows users, the important thing is to start building those guardrails now. Tools evolve quickly; your processes should evolve with them. The harness isn't a one-time setup — it's a living practice that will mature as your agents become more capable. And as Cherny's comments make clear, the engineers who thrive will be those who learn to direct AI, not just write code.