M7 · HOW I RUN MY DAY · OP2

The Build Playbook

Prototype in Perplexity. Architect with one window. Build with the other. Two AI sessions, one operator.

11 SLIDES · ~12 MIN · PLAYBOOK OVERVIEW
Key Takeaways
  • Prototype in Perplexity. Architect with one. Build with the other.
  • 2 hours — from idea to working prototype, end to end, including deployment.
  • 2 windows — of AI running at once: one architect, one builder, communicating through me.
  • 135 — production agents, scheduled jobs, and deployed apps I run as a single operator on this stack — each independently scoped, each with its own vault.
  • Open two AI sessions today. Use one as the architect and one as the builder. Notice the speed difference.
MODULE 7 · OPERATOR OP2

The Build Playbook

Two AI sessions. One operator. Prototype in one, build in the other.

BuildClub Academy
01 · WHY THIS MATTERS

Three numbers that explain why this matters.

2 hours
from idea to working prototype, end to end, including deployment.
BuildClub internal benchmark
2 windows
of AI running at once: one architect, one builder, communicating through me.
Two-window pattern
135
production agents, scheduled jobs, and deployed apps I run as a single operator on this stack — each independently scoped, each with its own vault.
BuildClub ops
02 · THE THESIS

Prototype in Perplexity.
Architect with one.
Build with the other.

The Thesis
03 · THE STACK

The four-layer build hierarchy.

1
2
3
4
1
Perplexity Computer — prototype
Test the thesis in 30 minutes. If the prototype doesn't argue for itself, kill it before it scopes.
2
Replit — deploy (prototype only)
Move the prototype to a real URL on day one. Deployment is one click; clients see it live. Never point Replit's agent at a production database — the July 2025 SaaStr incident is the cautionary.
3
Local — own
When the thing matters, pull it down. Run it on the laptop. Commit to GitHub. The cost curve crosses around production seriousness.
4
Anthropic Managed Agents — run
When the agent has to run by itself, on a schedule, in a sandbox, with vault access — move to the managed runtime.
04 · THE TWO-WINDOW PATTERN

AI on AI: two sessions, two jobs, one operator.

1
Window A — the architect
Long-context reasoning model (today: Claude Opus). Reads the whole repo, the docs, the prior decisions in Zep. Job: write the plan, write the diff, anticipate the edge cases.
2
Window B — the builder
Fast-loop coding model (today: Claude Sonnet or Claude Code on the CLI). Takes the plan from Window A, executes it on the file system, reports back. Job: ship the code.
3
The operator — me
I am the protocol between them. I read Window A, paste the directive into Window B, watch Window B execute, feed errors back to Window A. The bandwidth is human; the speed is machine.
05 · TOOL SELECTION

Local vs cloud, fast vs heavy — pick the right corner.

Local · Fast
Cursor, VS Code + Copilot. Inline edits, refactors, scripts. Latency under a second.
Local · Heavy
Claude Code on the CLI. Long refactors, full-repo edits, multi-file diffs. The serious workhorse.
Cloud · Fast
Perplexity Computer, Replit Agent. Prototypes, throwaways, exploratory builds. Optimize for time-to-URL, not code quality.
Cloud · Heavy
Anthropic Managed Agents, GitHub Actions. Scheduled, durable, audited. The thing has to run when you are asleep.

Match the corner to the job. The wrong corner costs hours.

06 · THE CLI DISCIPLINE

Four CLI rules I do not break.

1
2
3
4
1
Everything in a git repo
Including throwaways. A repo costs nothing; an unrecoverable file costs an afternoon.
2
Branch per attempt
I name branches by the experiment, not the feature. Failed branches stay; they are the receipt.
3
Secrets via Infisical, never in code
Even a five-minute prototype gets a real secret manager. The habit is the safety net.
4
Audit logs to S3
Every agent run writes a log line to S3. When something breaks at 3am, the log is already there.
07 · MACHINE TO MACHINE

Four ways agents talk to each other.

MCP — the standard
Model Context Protocol. The USB-C of agents. One server exposes tools; many clients consume them. Use it when you need clean interop between AI tools that already speak it.
GitHub Actions — the cron
Scheduled jobs that run a script. The script calls models, writes results, opens a PR. The audit trail is built in. Use it when the work runs on a schedule and you want it logged.
Webhooks — the glue
When something happens in one tool, fire a webhook to another. Cheap, durable, debuggable. The boring choice that wins when two SaaS tools need to talk in real time.
Browser control — the loophole
When the tool has no API, drive it with a browser. Perplexity (running Comet) drives Replit to actually build something. Anthropic's computer-use models drive whatever has a UI. Use it when there is no other way in.

Four integration patterns. None of them are sexy. All of them are durable.

08 · WHEN TO WATCH, WHEN TO WALK AWAY

Two operating modes: in the loop, or running unattended.

Attended — I stay in the middle
Perplexity running Comet driving Replit, with me reading every step. I want gates: I review what it's saying and what it's about to do before each move. Use this when the work is unfamiliar, the stakes are high, or I am still learning the agent's failure modes.
Unattended — it builds in the background
Same agent stack, no human in the loop. I hand it a directive, the agents run the build end to end, I come back to a working application. Use this when the pattern is proven, the failure mode is contained, and the cost of a wasted run is lower than the cost of my attention.
How I choose between them
If I cannot describe in advance what 'done' looks like, I stay in the loop. If I can — and the agent has already produced one good run end to end — I let it go. The choice is calibration over time, not a permanent setting.
The trap to avoid
Running unattended on work I have never done attended first. Every unattended pattern in my stack started as an attended one. The agents earn the right to run alone the same way a junior teammate does — by getting it right twice in a row while I was watching.

Both modes use the same stack. The choice is about my attention, not the agents' capability.

09 · OUTCOMES

What this stack actually produces.

Takeaways
  • 1 My personal yield as one operator with this stack is the yield of five to ten people. The team is still real; the agents are how each person on it gets to ten-person output.
  • 2 ~135 internal apps and pipelines run on this stack — built and maintained without spinning up a separate engineering function for each one.
  • 3 Client deliverables that used to take a small consulting team to produce now take one operator plus the stack — and the team is freed to do the strategy work that earned the engagement in the first place.
  • 4 85% of net-new client work in 2026 was scoped, prototyped, and delivered without ever opening a traditional IDE. The IDE moved into the AI session.
CLOSING

Five things to do Monday.

Monday Morning
  1. 1
    Open two AI sessions today. Use one as the architect and one as the builder. Notice the speed difference.
  2. 2
    Run one prototype in Perplexity Computer this week, end to end. Time-box it to 2 hours.
  3. 3
    Pick one internal process. Move it from a doc to a scheduled GitHub Action by Friday.
  4. 4
    Audit your secrets handling. If a single agent has access to everything, fix it before the end of the month.
  5. 5
    Stop treating IDEs as the unit of build. The unit is the stack.
OP2 · Questions CEOs Ask

Frequently Asked Questions

What is the core idea of The Build Playbook?
Prototype in Perplexity. Architect with one. Build with the other.
What does the data say a CEO should pay attention to?
2 hours from idea to working prototype, end to end, including deployment. 2 windows of AI running at once: one architect, one builder, communicating through me.
What should a CEO do Monday morning after reading The Build Playbook?
Start here: Open two AI sessions today. Use one as the architect and one as the builder. Notice the speed difference; Run one prototype in Perplexity Computer this week, end to end. Time-box it to 2 hours; Pick one internal process. Move it from a doc to a scheduled GitHub Action by Friday.
What are the steps in The Build Playbook?
1) Perplexity Computer — prototype; 2) Replit — deploy (prototype only); 3) Local — own; 4) Anthropic Managed Agents — run; 1) Everything in a git repo.
Where do the claims in The Build Playbook come from?
The playbook cites BuildClub internal automation portfolio; Fortune — Replit AI agent deletes SaaStr database (July 2025); BuildClub two-window pattern; Model Context Protocol (Anthropic).
OP2 · Sources

All Sources in This Playbook

00 / 11