A field report from running a production site with Lovable, Claude, and GitHub Copilot in one continuous loop — and what it taught us about scaling with a modern AI development workflow.
Most "we use AI" posts are aspirational. This one isn't. The site you're reading right now is built, shipped, and maintained by an AI development workflow in which AI agents handle the building and reviewing, and humans make the decisions. No hypotheticals — just the actual stack, the actual guardrails, and one honest failure.
If you run a lean team and you've been wondering whether the "AI-native software team" is real yet or still a demo, here's what it looks like in production while building with Lovable.
The stack, in one breath
Lovable builds and hosts the front end — React, Vite, TypeScript, Tailwind, shadcn/ui. We describe intent; it ships a working app and pushes the code straight to GitHub.
Lovable Cloud (Supabase) is the backend — auth, Postgres, and a fleet of edge functions powering everything from AI content tools to a live MCP server.
GitHub is the command center — the single source of truth for the code, where we triage bugs, where the entire roadmap lives as epics, stories, and tasks, and where we hand jobs to the right agent.
Claude is the senior engineer in the loop — it plans work, performs an AI code review on every pull request, and does the deep, careful reasoning.
GitHub Copilot's coding agent is the fast pair of hands — it writes and revises code against a clear spec, opens PRs, and responds to review comments.
Two AI systems that write, one that reviews, one platform that ships — all coordinated through GitHub. The humans set direction and hold the merge button.
Why three agents instead of one
Here's the counterintuitive lesson: the leverage isn't in a smarter single model — it's in separation of duties within the AI development workflow.
When one agent writes and judges its own code, it grades its own homework. It's confident, and confidence is exactly the wrong signal when you're hunting for bugs. So we split the roles the way a real team does:
Copilot writes because it's fast and tireless at turning a spec into a diff.
Claude reviews because a fresh AI code review from an adversarial reader catches what the author can't see.
The human decides because taste, priorities, and "is this actually worth doing" aren't delegatable.
That triangle — author, reviewer, owner — is the whole trick. It's not novel; it's how good engineering teams have always worked. We just staffed two of the three seats with AI.
GitHub is the command center, not just storage
If the agents are the team, GitHub is the office they all work in. It's easy to think of it as "where the code lives," but for us it does four jobs at once:
The source of truth for the code. Building with Lovable means every change is auto-pushed to the repo, so there's one canonical history — no matter which agent or human touched it last.
Where we triage bugs. Every defect becomes an issue with a clear repro and priority. Triage — deciding what's worth fixing, and when — stays a human call; the fixing gets handed off.
Where the whole roadmap lives. We keep work in a deliberate hierarchy: an epic is a big outcome (e.g. "grow organic traffic"), broken into stories (one shippable, user-visible increment each), broken into tasks (the technical steps). A tracking issue holds the epic; we split a story into its own issue only when we actually start it — so the board reflects reality instead of a graveyard of stale tickets.
Where we dispatch work to the right agent. An issue or a pull request is the hand-off. A well-specced issue goes to Copilot for implementation; a fresh PR goes to Claude for review; a thorny architectural question comes to a human first. Different jobs, different agents — routed through the same board.
That last point is the real unlock. Once your work is written down as issues and PRs, "employ an agent for this" stops being a novelty and becomes a routing decision: match the task to the agent best suited to it and let the platform handle the handoff.
What the loop actually looks like
Let me walk through a real change, because the specifics of this AI development workflow matter more than the theory.
We had a small but real bug: social link previews. When someone shared a page on LinkedIn, the preview card pointed at an image file that didn't exist — a dead reference that had been quietly 404-ing for who knows how long.
Copilot got the spec and opened a pull request: swap the broken image for the real branded banner, add the full set of Open Graph and Twitter card tags, and document the impact.
Claude reviewed the PR — providing a thorough AI code review that didn't just skim it. It checked the actual files: confirmed the old image genuinely didn't exist, confirmed the new one was the exact dimensions the new tags claimed (no mismatch — crawlers reject those). It signed off on the fix but caught one flaw: the docs credited the change to the wrong PR number.
Claude left a review comment asking Copilot to fix it.
Copilot pushed a corrected commit within minutes — and actually fixed three instances of the mistake, one more than the review had flagged.
A human read the two-line summary and clicked merge.
Elapsed human effort: about ninety seconds of reading. Everything else — the writing, the file verification, the correction, the follow-up — happened between the agents.
The part nobody tells you: know your walls
Here's the refreshing bit, and the reason this isn't a sales pitch.
The reason that social-preview bug existed is a hard architectural limit we hit and couldn't AI our way around. We'd built an edge worker to inject per-page preview metadata. It was correct code. We deployed it. It logged zero requests — because our hosting setup put one CDN layer in front of another, and our worker sat behind the layer that was actually answering the requests. No model, no prompt, no upgrade fixes that. It's physics, not intelligence.
So we did the mature thing: shipped the best fix the constraint allowed, documented exactly why the ideal fix is blocked and what would unblock it, and moved on.
That's the real skill in the AI era. The agents are astonishingly good inside the box you draw for them. The value you add as a human — or as a consultancy your clients pay for — is knowing where the box's walls are, and not wasting three weeks asking a language model to move a wall it can't see.
How to actually scale this
If you want to run an effective AI development workflow like this, a few hard-won principles:
Separate authoring from review — always. Never let the agent that wrote the code be the only one that approves it. An independent AI code review is where the bugs die.
Make the reviewer check reality, not vibes. "Looks correct" is worthless. The review that saved us verified files existed, and dimensions matched. Instruct your review agent to prove claims against the codebase.
Keep the human on the irreversible actions. Merging, deleting, publishing, spending money — those stay behind a person. Everything upstream can be automated aggressively.
Write your intent down. A clear project brief — we keep a living context file that every agent reads — is what makes an agent's output good rather than generic. Garbage spec in, garbage diff out.
Document your walls. When you hit a real constraint while building with Lovable, write down why and what unblocks it. Future-you — and your agents — will save days.
The takeaway
The future isn't "one AI writes your whole app." It's a small ensemble of specialized agents, each doing what it's best at, with a human holding the wheel on the decisions that matter. Fast hands, an adversarial reviewer, a shipping platform, and a person with taste and judgment.
You don't need a bigger team to move faster anymore. You need a better-orchestrated AI development workflow — and increasingly, most of that team is AI.
At Acacia Tech Group, we help data and AI teams design exactly this kind of leverage — AI-native workflows that ship real software with real guardrails, not demos. If you're trying to figure out where AI actually fits in your delivery pipeline, let's talk.
Created a hub-and-spoke diagram mapping the 'Triangle of Trust' workflow: GitHub as the central hub, where Human Strategy meets specialized AI agents (Copilot for writing and Claude for reviewing) to drive a production-ready software loop.