In January I wrote about how the most valuable AI work is often the least glamorous, and that the companies seeing real returns from AI aren’t the ones with the flashiest chatbot on their homepage, but the ones quietly rewiring how work gets done. I talked about production agents, staffing optimization, and conversational access to project data. All of it internal. All of it “boring.” All of it measurably useful.

That article ended with a line about turning AI from a slide in your strategy deck into a fabric that makes the whole business run better. We took that seriously. Over the past several weeks, we built a platform that embeds AI directly into how we deliver client work. Not as a feature we bolt on at the end, but as the core operating layer for how designers, developers, project managers, and eventually clients themselves collaborate on the same codebase. We call it Flock.

This article is about what we built, why we built it, and what it means for how agencies like ours can operate going forward.

I want to credit the engineering team at Ramp, who published a detailed writeup about building their own internal background coding agent. Their core insight was simple and powerful: if you give AI agents a proper development environment, with real tools, real test suites, and real access to the systems engineers use, they stop being toys and start being colleagues. Ramp reported that roughly 30% of all pull requests merged to their frontend and backend repos are now written by their internal agent.

That got our attention. But Ramp is a fintech company with hundreds of engineers. The question we kept coming back to was: can this pattern work for agency? Not just for engineers, but for the entire cross-functional team that delivers multiple projects for potentially hundreds of clients?

The coding agent space is getting crowded. Everyone from startups to the major AI labs is shipping tools that help individual developers write code faster. That’s useful, but it wasn’t the problem we needed to solve.

Our problem was coordination. At MCD Partners, a typical project involves developers, designers, a project manager, and a client, all contributing to the same deliverable but working in fundamentally different ways. Developers live in code editors and terminals. Designers think in components and visual systems. PMs think in scope, timelines, and documentation. Clients think in outcomes and brand requirements. These groups have always been connected by meetings, tickets, and handoffs. Layers of translation that slow everything down and introduce error at every boundary.

The deeper issue is that the code repository is the single source of truth for what’s actually been built. It’s where decisions materialize. But historically, only developers could meaningfully interact with it. That means designers file tickets asking developers to move a button 8 pixels. PMs write requirements documents stored in Drive that developers have to interpret. Clients see a staging site and send feedback that passes through two or three people before it reaches the code.

We wanted to collapse that. Not by making everyone a developer, but by giving every role on the team a way to interact with the codebase through AI, with appropriate guardrails, appropriate permissions, and appropriate expertise baked in.

The workflow is intentionally simple. You open Flock, select a repository, describe what you want done in plain language, and click start. A cloud sandbox spins up with the full development environment: the repo, the dependencies, the build tools, everything. An AI agent begins working on the task. You can close your laptop and walk away, or watch via live preview as it builds your solution.

When the work is done, you get a notification. You can review the changes from your phone, your tablet, or any browser. If it looks good, you approve it and create a pull request. If it needs adjustments, you open the chat panel and give follow-up instructions. The agent picks up where it left off.

The key difference from other AI coding tools is that Flock is designed around the idea that the person starting a task might not be a developer. A designer can ask Flock to update the spacing on a component, adjust a color palette, or implement a new layout. The platform gives the AI agent a design-specific persona, design-aware skills, and file-level permissions that prevent it from touching infrastructure or backend code. A project manager can ask Flock to update documentation, write a project brief based on what’s actually in the codebase, or draft release notes. The agent is constrained to documentation files with read-only access to source code for reference.

Developers get full access, naturally. But the point isn’t who gets the most freedom. It’s that everyone is working through the same system, against the same repository, with the same review and approval workflows.

There’s a common misconception that AI development tools are about replacing people. In our experience, the opposite is true, but only if you have the right people.

What Flock actually does is change the ratio. A senior developer who used to spend their day writing implementation code can now spend that time reviewing, directing, and architecting while AI handles the line-by-line work. One senior engineer can effectively oversee the output of what used to require a much larger team, because the bottleneck shifts from “who can write this code” to “who can judge whether this code is right.”

This is where an agency with deep senior talent has a structural advantage. Our teams aren’t junior developers learning on the job. They’re people with 10, 15, 20 years of experience who know what good looks like and can spot problems in seconds. Flock turns that expertise into leverage. The senior architect reviews the AI’s work and catches the subtle issues: the edge case the agent missed, the accessibility concern that wasn’t in the prompt, the performance implication of a particular approach. Their judgment is the quality floor.

For non-developer roles, the same principle applies through approval workflows. When a designer or PM creates work through Flock, it doesn’t ship automatically. A developer reviews it, approves it or sends it back with feedback. The AI does the work. The humans ensure it meets the standard. This is how you maintain enterprise-grade quality while moving at a pace that would have been impossible with traditional staffing models.

The natural question any client or technical leader asks about AI-generated code is: how do you know it’s safe? How do you know the agent didn’t introduce a vulnerability, break an existing feature, or make a decision that looks right on the surface but falls apart under load? That’s a fair question. And the answer can’t be “we trust the model.” The answer has to be structural.

Flock’s control model starts with a hard constraint: the AI has no push access to the repository. It cannot ship code. Every sandbox is isolated, and every change the agent makes stays local until a human reviews it and explicitly approves the merge. This is the same pull-request-based review workflow that professional engineering teams have relied on for years. The only difference is that the initial implementation comes from an AI agent instead of a junior developer, and the senior engineer reviewing it has full visibility into every file changed, every command run, and every decision the agent made along the way.

Permissions go deeper than the review step. Each role’s boundaries are enforced at the agent level, not just in the UI. A designer’s AI agent cannot modify backend code, database schemas, or infrastructure files, even if explicitly asked to. A project manager’s agent has read-only access to source code so it can reference real implementations when writing documentation, but it can’t change a line. These aren’t guidelines or best practices. They’re configuration-level constraints that the agent cannot override.

The security posture follows the same philosophy. Access is restricted to authorized organization members. Environment secrets are encrypted at rest and injected only at runtime. No credentials are stored in sandboxes. Every change is captured in version control with a full audit trail. This is full-stack development with the same review rigor you’d expect from a senior engineering team, operating at a pace that wasn’t previously possible.

This is the part that excites me most, and the part I think is genuinely new for our industry.

In a traditional agency workflow, the handoffs between disciplines are where quality degrades and time is lost. Design happens in Figma. Development happens in GitHub. Project management happens in Jira or Asana. Client feedback happens in email or Slack. Each system has its own version of the truth, and keeping them synchronized is a full-time job that nobody wants to do.

Flock doesn’t eliminate all of those tools, but it creates a shared layer where every role interacts with the actual work product, the code, through an interface that’s appropriate for their skill level and responsibilities. The repository becomes the shared operating surface.

When a designer adjusts a component through Flock, that change is visible to the developer reviewing the next pull request. When a PM updates project documentation, it’s in the same repo that the AI agent reads for context on the next task. Each role has its own AI persona, its own set of skills, its own model configuration, and its own permission boundaries. But they all share the same source of truth.

This is what I mean when I talk about the code repository as memory. Every change, every decision, every iteration is captured in version control. The AI agent reads the project’s own documentation before starting work. It understands the codebase it’s working in. When team members switch between tasks or pick up where someone else left off, the context is already there. Not in someone’s head or a Slack thread, but in the system itself.

This might sound like a small detail, but it changes behavior in ways that matter. Because Flock runs entirely in the cloud, you don’t need a development machine to start or review work. The sandbox has all the compute, the dependencies, and the tools. Your device is just a window into it.

That means a creative director can review a design implementation from their phone on the train. A developer can kick off a task from their tablet before bed and review the results over coffee. A PM can start a documentation task between meetings without setting up a local environment. The work isn’t tied to a machine. It’s tied to the idea and the people responsible for it.

In an agency where people are constantly moving between client meetings, travel, and multiple projects, this kind of untethering is operationally significant.

We’re already in early testing on the next phase that will include client access. Today, Flock’s role system supports developers, designers, and project managers, each with their own AI configuration, permissions, and approval workflow. The architecture was designed from the start to extend that same pattern to a client role.

The partner access a client can log in, see their project, and can interact with the work directly. Not by writing code, but by describing what they want changed and letting the AI, guided by the senior expertise embedded in the system’s configuration, handle the implementation. Every change goes through the same approval workflow. Every iteration is captured in version control. The client gets senior-level execution speed without consuming senior-level hours for routine adjustments.

When this is fully rolled out, it will mean that the feedback loop between “client has an idea” and “the idea is implemented and reviewable” shrinks from days to minutes.

If there’s one thing I’d want someone to take away from this, it’s that Flock isn’t the final idea. The platform is a means to an end. The actual differentiator is a way of thinking about how AI should be integrated into the way a business operates.

Most organizations are still treating AI as a set of discrete tools: a coding assistant here, a writing tool there, a chatbot for customer service. Those tools are useful. But the compounding gains come when you design the system around the work, when AI isn’t an add-on but the operating layer that connects people, process, and output.

That’s what we set out to build. Not a better coding assistant, but a platform that reflects how our teams actually work: cross-functional, senior-led, async, and increasingly untethered from any single machine or location. The fact that we built it ourselves, rather than waiting for an off-the-shelf product to close the gap, means it evolves at the speed of our business. We can add new roles, new skills, new workflows, and new integrations as the work demands them.

For agencies and professional services firms watching the AI space, I think the real question isn’t “which tools should we adopt?” It’s “how do we want work to flow through our organization, and how does AI make that flow better?” The answer to that question is going to look different for every firm. At MCD Partners, it looks like Flock.