Built with Devin & Windsurf

How Green Teagentic was architected using Cognition’s Devin and the Windsurf agentic IDE — a behind-the-curtain look at the dual-agent workflow that shipped the matcha-dark workspace.

The two-agent build pipeline

Green Teagentic was not written by a single human at a single keyboard. It was brewed — assembled through a tightly coupled pair of autonomous coding agents operating in a planner / executor split, with a human acting as taste-tester and merge gatekeeper.

The stack:

• Windsurf — the local agentic IDE, home of Cascade (the in-editor agent that reads the repo, edits files, and runs the dev loop) and Tab (the flow-state autocomplete that handles imports, refactors, and dependency stitching with a single keystroke).
• Devin — Cognition’s autonomous cloud engineer. Devin spins up its own VM, clones the repo, runs tests, opens PRs, and works asynchronously while the local IDE stays free. It is the same agent that Nubank used to refactor a multi-million-line ETL monolith with a reported 8–12× engineering efficiency gain and ~20× cost savings.

In Windsurf 2.0, the two are fused: Cascade plans, Devin executes in the cloud, and the diff lands back in the local worktree without a context switch. Green Teagentic was built end-to-end on top of that handoff.

The workflow we actually used

1. Steep — intent capture in Cascade

   Every feature began as a natural-language brief inside Windsurf’s Cascade panel. Cascade’s deep codebase index resolved the brief against the existing TanStack Start route tree, the Lovable Cloud schema, and the brew pipeline primitives — producing a structured plan (files to touch, server functions to add, RLS policies to author) before a single line was written.

2. Pour — local execution via Cascade + Tab

   For surface-level work — UI polish, component variants, design-token refactors against src/styles.css, route additions — Cascade edited in-place and Tab handled the long tail of import wiring. The matcha-dark theme, the panel glass treatment, and the terminal-style typography were all tuned in this tight inner loop.

3. Delegate — async heavy lifting to Devin

   Anything that touched more than ~5 files, required long-running test cycles, or involved schema migrations was handed off to Devin with one click from Cascade. Devin booted a fresh sandbox, ran bun install, executed the migration plan against a scratch Supabase branch, ran the full Vitest suite, and opened a PR with a written rationale.

   This is where the agentic aspects of the product itself were built: the multi-stage brew pipeline, the MCP server surface, the recipe replay engine, and the Cellar’s vector recall — all shipped as Devin PRs.

4. Critique — agent-on-agent review

   Every Devin PR was first reviewed by Cascade locally (running a structured critique-brew against the diff) before a human ever opened it. Cascade flagged token drift, missing RLS grants, and untyped server-fn inputs against the project’s own rule set. Only PRs that survived the agentic critique reached the human reviewer.

5. Pour back — merge, invalidate, redeploy

   Merged PRs triggered a redeploy to the Lovable Cloud edge runtime. Cascade’s awareness of the new commit propagated automatically, so the next planning turn began with a fresh index — no manual re-ingest, no stale embeddings.

Why two agents instead of one

A single agent — even a strong one — collapses under the cognitive load of holding plan, edit, test, and review in the same context window. The split mirrors a senior/junior pairing:

Concern	Owner	Why
Codebase intent & taste	Cascade (local)	Real-time awareness of the developer’s cursor, open files, and last-typed thought.
Long-horizon execution	Devin (cloud)	Owns its own machine, can run for hours, parallelizable across many tasks.
Inline flow & boilerplate	Windsurf Tab	Sub-second autocomplete that closes the gap between thought and keystroke.
Final human judgment	The brewer	Merges, tastes, ships.

The result is a workflow where the human is never the bottleneck on typing and never the bottleneck on waiting. Plans flow into Cascade, executions fan out to Devin, critiques flow back, and the matcha keeps steeping.

What this means for the product

The same dual-agent pattern that built Green Teagentic is the pattern the app itself exposes to its users. A brew is a Devin-style long-running delegation; a recipe is a Cascade-style reusable plan; the Cellar is the shared memory both agents read from. We did not retrofit the metaphor — we lived it for the entire build, and then shipped the parts that worked.

Try the workflow yourself

Start a brew and watch the planner / executor split run inside Green Teagentic. The same shape that built the app powers every pour.