Scaling With Agents

Source: Dev.to

Introduction

The current generation of frontier models are incredibly capable. It’s no longer a question of what you can build, but how fast you can build it. Building quickly at scale introduces its own complexity: scaling compute and scaling agents are two distinct challenges that must be tackled in lockstep.

Planning with Claude

With Claude Code you’re effectively a CTO. If you previously enjoyed writing artisanal Python, you now need a new set of skills to operate at the scales these models enable. Implementation details become a waste of time; instead, break large projects into smaller, independent features that can be developed in parallel.

I use GitLab together with the glab CLI tool to have Claude help me plan everything out. An interview‑style, back‑and‑forth conversation works well because a perfectly constrained statement of work is impossible to provide in a single prompt. This iterative dialogue reshapes my perception of the project as we progress.

Choosing the Right Stack

Infrastructure constraints (e.g., running on a MacBook or a familiar cloud) are fine, but let the agent decide the details. Remember, as a CTO you’re focused on vision, not on forcing a preferred language. I personally dislike JavaScript, yet for many projects it’s the right tool and Claude understands it exceptionally well. When I stopped imposing my preferred stack, the agents coordinated much more smoothly.

Managing Agents

Breaking Down Work

Plan thoroughly: create sprints, epics, and crawl/walk/run roadmaps. Agents are stateless, so overloading them degrades performance. Provide layered resources—merge‑request descriptions, codebase snapshots, documentation—that the agent can query when needed. Most of the time the MR description and codebase suffice; for ambiguous problems the agent can fetch additional context on its own.

Orchestration

A well‑structured breakdown helps the orchestration agent know what to tackle next. If the orchestration agent must understand every ticket and the entire codebase on each iteration, it will fail. I skim all tickets and sprints before letting agents work, intervening only when alignment issues arise. One of my favorite prompts tells agents to review the ticket, merge‑request description, docs/, and the codebase to ensure everything stays in sync, using multiple independent agents for exhaustive coverage.

Aligning Language and Documentation

Think of your code as English: docs/ become the source of truth, and open work items describe the path forward. Any divergence can be explained to the agent, which then corrects the issue automatically.

CI/CD Pipelines

When you’ve broken the project into a detailed plan, you may still be limited by hardware that can barely run the test suite, let alone run it ten times in parallel for multiple agents.

CI/CD pipelines solve this. Setting up a pipeline for tests and linting is often the first hurdle for startups, but it aligns the team on workflows and gives each agent a sandboxed environment. With eight agents working through a two‑week sprint in parallel, sandboxing prevents them from stepping on each other’s changes.

Infinite Compute

Agents require an over‑engineered test suite to protect workflows. Because agents are stateless, they need clear pass/fail signals; otherwise they can break the iteration loop. The test suite is typically 10× larger than a human‑written one, and running it concurrently for multiple agents quickly overwhelms a single development machine. A CI/CD pipeline distributes the workload across unlimited compute resources, eliminating this bottleneck.

Scaling Tips

• Break problems into granular chunks up front.
• Provide layered, queryable resources (tickets, MR descriptions, docs).
• Use CI/CD pipelines to sandbox agents and supply infinite compute.
• Align the team on workflows; pipelines become the shared contract for agent behavior.
• Avoid babysitting agents—let them operate independently once the infrastructure is in place.

Conclusion

Scaling with agents is now a proven, high‑impact approach. By planning meticulously, leveraging Claude for orchestration, and harnessing CI/CD pipelines for sandboxed, parallel execution, you can achieve massive productivity gains and manage the entire software development lifecycle for multiple startups.