Claude is the pair programmer behind Pagayo.

The engineer in
the chair next to mine.

Claude reads the codebase, weighs trade-offs, writes careful changes, catches the bugs I would have shipped, and explains its reasoning along the way. Most of what gets built at Pagayo is built in conversation with Claude — and the platform is sharper for it.

Visit anthropic.com ↗
200k
Token context per turn
12
Claude capabilities in use
1
Pair programmer, always on
0
Black-box edits, ever
The toolkit

Twelve Claude capabilities. One workflow.

Opus, Sonnet, Haiku, tool use, long context, vision, artifacts, computer use, prompt caching, citations — every Claude feature plays a role in the daily Pagayo loop. Here is the full set.

  • Opus 4.7 Reasoning

    The flagship model behind the careful refactors and architectural reviews.

  • Sonnet Fast

    Quick, balanced edits for the everyday loop — small features, small fixes.

  • Haiku Instant

    Snappy inline help, tagging and rewording with sub-second latency.

  • Tool use Agents

    Claude picks the right Pagayo agent tool — file edit, shell, search.

  • Long context 200k

    Pulls whole repos into a single turn — no lossy summarisation.

  • Vision Multimodal

    Reads screenshots, design mocks, error dialogs — fixes UI by eye.

  • Artifacts Outputs

    Self-contained code blocks that drop straight into the repo.

  • Computer use Autonomy

    Drives the editor when the loop is mechanical — open, edit, save.

  • Prompt caching Efficient

    Codebase context is cached across turns — fast, cheap, repeatable.

  • Citations Grounded

    Answers cite the file and line — no invented APIs, no guesses.

  • Constitutional Safety

    Refuses destructive ops by default — no `rm -rf`, no force-push.

  • MCP Connectors

    Custom servers expose Cloudflare, D1 and Stripe directly to Claude.

How it fits together

Six layers, one collaborator.

Pair programmer, long context, careful diffs, reasoning, review, safety. Here is what each layer of working with Claude looks like at Pagayo.

01 Pair programming

The engineer in the chair next to mine

Not autocomplete. A colleague.

Most of what gets built at Pagayo is built in conversation with Claude. Pagayo describes the intent — "rework the order-detail header so it works for POS too" — Claude reads the files it needs, proposes an approach, points out the edge case Pagayo missed, and writes the diff. Every turn is a small design review. The platform is sharper for it.

  • Conversational design review on every change
  • Explains the trade-off before it picks one
  • Points out the second-order effect, every time
PAGAYO"rework header for POS"CLAUDE"reading 3 files…"order-header.tsx · 42 + / 12 −++−+
02 Long context · Citations

Reads the whole codebase, every turn

Twelve repos. One window. No lossy summary.

Claude's long-context window swallows the relevant files whole. When the conversation touches the order service, it reads the schema, the service, the route, the test, the consumer in storefront and the contract in api-stack — all in the same turn. Citations point to the file and line. No invented APIs. No "I think this exists somewhere".

  • 200k tokens — entire packages in one prompt
  • Cites the file and the line, every answer
  • Sees the whole call chain across repos
order.service.tsstorefrontorder.schema.tsschemaorder.route.tsapi-stackorder.cache.tsedgeorder.workflow.tsworkflowsorder.spec.tsmaintenanceorder.config.tsconfigorder.admin.tsxstorefrontCONTEXT200ktokens
03 Edits · Artifacts

Diffs you can actually review

Small, contained, reviewable.

Claude writes diffs the way a senior engineer does: smallest possible change, no opportunistic refactors, no rewriting code it wasn't asked to touch. Variable names match the file. Imports stay sorted. Comments stay rare. When a change is genuinely big, Claude breaks it into reviewable chunks and stops between them to confirm — no surprise 800-line PRs.

  • Minimal-diff edits — no drive-by refactors
  • Matches the file's existing style and patterns
  • Stops mid-task to confirm before big leaps
order.service.ts12 13 14−15+16+17 18 19−20+21 22 23+24
04 Extended thinking

Reasons out loud — no black box

You can see the trade-off being weighed.

When the question is hard, Claude shows its work. The plan comes before the code. Trade-offs are named: "Cache-first is faster but breaks under tenant rotation — going with KV-keyed-by-version instead." It is the engineering reasoning a senior reviewer wants to see in a PR description, written before the PR exists. Every decision is reviewable, every assumption is checkable.

  • Plans the change before it writes the code
  • Names trade-offs in plain language
  • Flags assumptions — you can correct them early
PLAN · BEFORE THE CODE1Read cache layer in edge/2Check tenant rotation guarantees3Trade-off: cache-first vs KV-keyed4Pick KV-keyed-by-version5Update cache.ts + 2 callers6Add regression test→ proceed? assumptions checked
05 Code review

Catches the bugs I would have shipped

A second pair of eyes — pessimistic by design.

Pagayo's CodeReview subagent runs on Claude Opus. It reads the diff, walks the consumers, checks the tests, and flags what humans miss: missing idempotency keys, accidentally awaited promises, schema mismatches with @pagayo/schema, broken cache invalidation, Order-First violations. Pagayo merges what Claude clears. The five-pillar standard gets enforced before main.

  • Architectural review on every meaningful PR
  • Spots Order-First violations and schema drift
  • Verifies test coverage — refuses uncovered diffs
#412 · order header posclaude-review!Missing idempotency key on webhook!Cache invalidation skips POS rows!Order-First: source vs originator mixed✓Schema check passes · @pagayo/schema✓Coverage: 100% on diff✓Approved with 2 must-fix
06 Constitutional AI

Careful by default

Refuses destructive ops without confirmation.

Claude is trained to be cautious where it matters. `rm -rf`, `git push --force`, dropping a table, deleting a branch — it stops and asks. Production deploys are explicit, not implicit. Secrets stay in the vault. The agent rules in every Pagayo AGENTS.md are read on every turn, and the model genuinely behaves differently because of them. Safety is not a wrapper, it is a property of the model.

  • Stops before destructive shell commands
  • Respects AGENTS.md rules per repository
  • Production deploys are always opt-in, never default
edit src/order.ts run npm test rm -rf node_modules git push --force wrangler deploy prod commit + push staging AGENTS.md read-only opt-in only stop & ask
Why this matters for you

Code you can trust because it was reasoned about.

You will never see Claude in the product. What you will feel is the cadence of the work behind it: small, careful changes that land cleanly. Bug fixes that include the regression test. Refactors that don't leave dead code behind.

Claude makes Pagayo possible at one-operator scale: long context to hold the whole platform in one head, careful diffs to keep the code reviewable, reasoning out loud so every decision is checkable. The engineer in the chair next to mine.

That's the "Claude inside" advantage.

Start selling today.
Grow with the platform.

Free to start. All features included. Yours to leave whenever you want — most never do.

Start Free → Compare Plans

Have an idea, a question, or a feature you wish existed? Get in touch — we listen.