← All sessionsHomeSearch
AI Sprints (Live Weekend Programs)·WindSurf and Devin Sprint·1:52:17

AI Sprint: Windsurf & Devin — Day 2 (Building Superplexity: Plan with Opus, Execute with Cascade, Review with Devin)

Dileep (KVSS Dileep) Head of Generative AI Education at Outskill; runs the whole pipeline live — interview-driven spec in Claude Code (superpowers skill), sub-agent execution in Windsurf, and a parallel Devin code-review on an earlier build · Kartik Host — recap framing, Alumni Forge go-live, CSAT poll, Catalyst close

Session map

THE LANESTHE BUILDTHE LANDINGIDE vs autonomous agentlocal Windsurf, cloud-sandboxed Devin,…Plan with Opus, execute with…the two-model build ritualThe Superplexity speccurated-source bias, weighted blending,…Devin on existing codereview report, own branch, self-analyze…The MVP lands imperfectthin coverage, stale sources, and the f…
The lanesThe buildThe landing
click a node — its card pops up (drag it anywhere, × to close)
Concept

The map reads left to right — the lanes flow into the build, then into the landing. Click any node to open that idea here; every timestamp jumps into the recording.

The short version

  1. The division of labor is the session: 'Windsurf is an AI IDE. Devin is an autonomous coding agent.' Windsurf works on YOUR machine ('shut the laptop, it stops'); Devin works in ITS OWN CLOUD SANDBOX ('shut the laptop, Devin is still working') — sandbox explained with the restaurant's testing kitchen: 'make the wild dish there, taste it, then bring it to the main kitchen.' Cursor+Claude Code ≈ Windsurf+Devin, and since everything forks VS Code, 'any IDE has 70-80% feature overlap — combine anything you want.'
  2. The build ritual is PLAN-WITH-OPUS, EXECUTE-WITH-CHEAP: Claude Code (Opus + the superpowers brainstorming skill) interviews him into a Superplexity spec — 'we haven't written a single line of code; I'm still doing the planning only' — then Windsurf's Cascade implements the plan file with sub-agent-driven development on adaptive (cheap) models. The economics are war-storied: 'in the engineering cohort, Claude ran out of usage limits FOUR times... Opus for planning only.'
  3. The spec itself is the best worked example of Day 1's doctrine: the thesis ('Perplexity searches the wrong web — bias retrieval toward high-signal independent writing, not SEO-optimized blog spam'), weighted source blending (newsletters 1.0, tweets 0.7, Google fallback 0.4), Twitter via Apify with a daily budget, PAID SCRAPING ON DEMAND ONLY ('otherwise my money will get drained'), six accepted edge-case defaults (thin results, paywalls, conflicting sources, hallucination checks, API failures, stale lists), and Sonar replacing Google — 'I'm building a better Perplexity, so I'm using Perplexity's own search model.'
  4. SPECS vs PLANS, finally distinguished by artifact: 'the spec is proper English — for YOU to verify. The plan is technical — for the AGENT. Plan is for the agent; spec is for you.' The handoff is just a file reference: Claude writes docs/plans/, Cascade implements @plan — no copy-paste.
  5. Devin's lane is EXISTING code: point it at a repo and it returns a review report (4 bugs, 7 code-quality issues, missing features, improvement ideas), fixes on its own branch, raises the PR, analyzes its own merge-worthiness, and passes CI — 'extremely good at migrating legacy code... COBOL, Fortran, Angular to React.' The founder-pedigree argument seals it: Scott Wu, three IOI golds, 'one of the best coders in the world is building the software-engineering agent.'
  6. And the MVP lands honestly: first query fails ('thin coverage — no usable sources' — the database was empty), gets debugged by pasting the error back; the working answer cites slightly stale sources ('it says 4.6 while we're at 4.7'); and the closing claim earns its confidence: 'it's pretty decent because I made a very good plan first. Make a great plan, and anybody can execute it. Even in management.'

The concepts

01

IDE vs autonomous agent: local Windsurf, cloud-sandboxed Devin, and free combination

'Windsurf is local — shut your laptop and it stops. Devin is on the cloud — shut your laptop and Devin is still working.'

The taxonomy: an IDE (Windsurf, Cursor, VS Code descendants) is where YOU set up the codebase and collaborate with an agent locally; an AUTONOMOUS CODING AGENT (Devin) takes a task — 'fix the bug, implement the feature' — into its own CLOUD SANDBOX and works it end to end. Sandbox gets the restaurant treatment: 'instead of testing the wild dish in the main kitchen, the chef says: here is a testing kitchen. Make it there, taste it, then bring it in' — a protected environment where experiments can't hurt production. The pairing insight: Cursor+Claude Code is 'exactly like' Windsurf+Devin — IDE plus agent — and because every IDE descends from VS Code, the official Claude Code extension runs inside Windsurf too: 'any IDE you think of, there's 70-80% feature overlap. I can combine anything in any way I want.'

Devin's differentiators beyond the sandbox: Slack integration, automatic PR answering, and persistence — plus enterprise-shaped pricing ('a little off the curve') and a focus 'purely on software... not optimized for non-coding tasks,' where Claude Code and Codex stay the all-rounders.

Worked example · from the session

The live proof of persistence: Devin keeps fixing model-council bugs in its sandbox while he builds Superplexity locally — two agents, two machines, one operator.

Why it matters

It's the decision rule for where work should live: interactive building on your machine, long autonomous tasks in someone's cloud.

People get this wrong

IDE agents and autonomous agents are competing products.

They're complementary lanes of one workflow — the corpus keeps rediscovering this pairing (Cursor+CC, Windsurf+Devin, Codex+Hermes).

Windsurf is an AI IDE. Devin is an autonomous coding agent... shut down your laptop, Windsurf stops. Devin is still working, because Devin is on the cloud.
Here is a testing kitchen. Make the dish there, taste it, and then I'll get it into the main kitchen. That is a sandbox.
For your projects

The testing-kitchen line is the client-safe explanation for why your pipeline validates in a scratchpad before touching the live site.

Go deeper

In one line: IDE = local, collaborative, you-present (Windsurf/Cursor); autonomous agent = cloud-sandboxed, task-complete, persists without you (Devin); pair them freely (70-80% feature overlap across VS Code descendants), routing supervised work local and long autonomous work to the cloud.

The testing-kitchen sandbox analogy is reusable for every isolation concept — branches, VMs, staging ()

JetBrains named as equally combinable — 'plug Claude Code or Devin into any platform' ()

Devin runs 'a mixture' of models underneath, not a single LLM ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

Which lane for a 3-day dependency-upgrade grind across a legacy repo?

The cloud agent — it outlives your laptop sessions, works its own sandbox, and delivers as PRs you review; the IDE lane is for the work you steer minute to minute.

02

Plan with Opus, execute with cheap: the two-model build ritual

'Claude is super costly — in the engineering cohort it ran out of usage limits four times. So: Claude Code for planning, Windsurf for executing the plan.'

The ritual, demonstrated end to end: open Claude Code INSIDE Windsurf (VS Code extension), invoke the Obra SUPERPOWERS brainstorming skill, and let it interview you into a spec — 'I'm not jumping in with my features; I'm setting up an interview between me and Claude Code.' Opus plans because 'Claude Opus is one of the best planning things available.' Then the artifact chain: the BRAINSTORM produces a SPEC ('proper English — for YOU to verify'), the writing-plans skill converts it to a PLAN ('very technical — for the AGENT... user stories, sprints, all written in'), and Cascade implements it by file reference — '@ the plan file, say implement this' — kicking off 'sub-agent-driven development' on Windsurf's cheap adaptive models. No copy-paste between tools: Claude wrote docs/plans/ into the same folder Cascade reads.

The non-technical escape hatches are taught as first-class moves: 'I am a completely non-tech person — simplify this and tell me where you need my direction' resets a spec gone jargon-heavy; recommendations can be overridden ('you can push back — I don't want this, do that'); and skills install by pasting the GitHub link ('drop it into Claude Code and say install it — don't have to worry').

Worked example · from the session

The closing credo: 'It's pretty decent because I made a very good plan first. Once I refined my plan, anybody can execute it. Even in management — make a great plan and tell people with muscle to execute it.'

Why it matters

This is the sprint track's routing doctrine (judgment to frontier, bulk to cheap) expressed as a two-tool pipeline with a file as the interface.

People get this wrong

Using two AI tools means copying context between them.

The folder IS the interface — planner writes markdown, executor reads it; the md-file doctrine yet again.

Plan with Opus, execute with cheap Opus plans expensive, runs ONCE spec · architecture · tasks Cheap executes runs MANY times task by task from the plan Devin reviews own branch, self-analyzed PR Pay for judgment once, buy labor cheap — then let a third agent review the work on its own branch
Pay for the plan once, execute with the cheap model many times, review on its own branch
Claude ran out of usage limits four times. So I use Claude Code for planning, and Windsurf for executing the plan.
The spec is proper English — for you to verify. The plan is very technical — the plan is for the agent.
We haven't written a single line of code. All that we are doing is the planning.
For your projects

This is the architecture of your own scheduled tasks: premium judgment writes the plan (queue rules, method), cheap execution follows it.

Go deeper

In one line: Two-model ritual = frontier model + interview skill produces spec (human-readable) then plan (agent-readable) in-repo; cheap adaptive models execute the plan by file reference; push back on recommendations, simplify on demand, and never pay frontier prices for implementation tokens.

The spec/plan split maps to audience: spec = verification surface for humans; plan = execution surface for agents ()

Windsurf's Opus lockout (BYO Anthropic key) is WHY the extension route exists — work around vendor walls with the shared folder ()

'We haven't written a single line of code' repeated like a mantra through 40 minutes of planning — the discipline is the demo ()

Design injected as data: a free design-system site's design.md pasted in for UI direction ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

Why does the plan live in the repo instead of the chat?

The repo is the shared memory both tools read — the handoff is a file path, survives sessions, and versions with the code. Chat handoffs die with the window.

03

The Superplexity spec: curated-source bias, weighted blending, and budget-gated scraping

'Perplexity searches the wrong web. You want to bias retrieval towards high-signal independent writing and curated tweets — not SEO-optimized blog spam.' The agent's own restatement of his thesis, and the whole product in one sentence.

The interview surfaces every decision Day 1 said a spec needs. SOURCES: Substack/Beehiiv newsletters and curated Twitter accounts as the high-signal pool, hybrid with wider search; the source LISTS are agent-researched ('get me the top AI substacks, beehiivs, accounts — search yourself'). SCORING: weighted blend — all sources run in parallel, rescored by source weight (newsletters 1.0, tweets 0.7, Google fallback 0.4) — chosen over pure tiering or classifier routing. COST CONTROL: Twitter via Apify actors ('the X API is $200/month; scraping is fragile — hybrid recommended'), and the hard rule PAID SCRAPING ON DEMAND ONLY — 'only when I ask, with that scope. Don't keep scraping; my money will get drained' — with the clarifying nuance the agent itself surfaces: free RSS polling can stay background; paid calls cannot. EDGE CASES: six defaults accepted explicitly — thin results ('synthesize and SAY thin coverage'), paywalls (cite what's accessible, flag it), conflicting sources (surface the disagreement), hallucination post-check, graceful API-failure degradation, stale-list passive feedback. SEARCH: Sonar (Perplexity's model, via OpenRouter) replaces Google entirely — 'I'm building a better Perplexity, so I'm using Sonar.' STACK (recommended, accepted): thin orchestrator, SQLite FTS5, no vector store ('top 20 articles back to Sonnet — we don't need one'), Next.js front end, keys in .env.

Worked example · from the session

Authentication deliberately skipped — 'I don't want to worry about authentication for now' — Day 1's build-auth-last rule, obeyed in its own spec.

Why it matters

It's the corpus's most complete worked spec: every Day 1 concern (edge cases, limits, errors) appears as an actual decision with a chosen default.

People get this wrong

A search product's quality comes from its synthesis model.

This spec spends 90% of its decisions on RETRIEVAL — source pools, weights, budgets, freshness. Synthesis is one line; the wrong web ruins any model.

Perplexity searches the wrong web. You want to bias retrieval towards high-signal independent writing and curated tweets, not SEO-optimized blog spam.
The scraping should happen on demand. Don't keep scraping — otherwise my money will get drained.
For your projects

'Bias retrieval toward high-signal independent writing' is also a one-line description of what your KB does to course content — curate first, synthesize second.

Go deeper

In one line: Superplexity spec = curated-source retrieval (newsletters + tweets) with weighted blending, on-demand-only paid scraping under a daily budget, six named edge-case defaults, Sonar-for-search via OpenRouter, thin-orchestrator architecture (SQLite FTS5, no vector store), auth deferred; produced by interview, verified in English, executed from the technical plan.

Weighted blend beats hard tiers because signal is probabilistic, not hierarchical — the agent's recommendation, adopted ()

The agent catches HIS ambiguity ('all fetching, or specifically the paid scraping?') — good specs are co-edited ()

'We don't need a vector store' is a scale-honest call: 20 articles into a long-context model beats infrastructure ()

Design direction arrives as a pasted design.md from a free design-system site — aesthetics as spec input, not afterthought ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

Why weight Google fallback at 0.4 instead of excluding it?

Coverage insurance: the thesis biases toward curated sources but the blend keeps breadth available at a discount — exclusion would turn thin-coverage cases into dead ends.

04

Devin on existing code: review report, own branch, self-analyzed PR

'Devin is extremely good at migrating your code — COBOL, Fortran, old languages... existing code modification is what Devin does very well.'

The demo: point Devin at the model-council repo (built in an earlier sprint) — 'go through the repository, tell me if there are bugs, discuss with me before next steps.' Devin clones it into its cloud sandbox and returns a structured REVIEW REPORT: 4 bugs (duplicate prompts wasting tokens, an .env sentinel mismatch), 7 code-quality issues, missing features, improvement ideas. On 'go ahead and fix,' it creates 15 tasks, works its OWN BRANCH, raises a pull request, runs the CI checks, ANALYZES ITS OWN PR for merge-worthiness ('if everything is fine, it merges; if not, it won't') — and finds additional bugs mid-fix, pushing those too. The GitHub view closes the loop: two branches, the PR trail, automated checks — Day 1's pizza mechanics, operated by an agent.

The context that frames trust: Cognition's founder Scott Wu — three IOI golds, ICPC podium, 'legendary grandmaster... one of the best coders in the world is building the software-engineering agent.' And the lane discipline: 'more for software engineers, but non-engineers can use it — it's just more technical'; enterprise pricing; for greenfield, Windsurf; for legacy, Devin.

Worked example · from the session

The migration pitch made concrete: 'companies with legacy code — Angular to React, old frameworks — there I would really suggest Devin.'

Why it matters

It's the corpus's first full autonomous-review loop on a REAL prior artifact — the existing-code scenario 'we typically don't show... where things break.'

People get this wrong

Autonomous agents are for building new things.

Devin's economic core is the UNGLAMOROUS lane — migrations, refactors, bug burn-down on code that already exists, where supervised building is too slow and rewriting too risky.

The person building the company on top in software-engineering agents is one of the best coders in the world.
For your projects

The model-council repo getting agent-reviewed months after its build is the maintenance story for every artifact this KB documents — worth scheduling for your own repos.

Go deeper

In one line: Devin workflow = repo in → sandboxed analysis → structured review report (bugs/quality/missing/improvements) → approved fixes on its own branch → PR with CI + self-analysis → merge; strongest on legacy migration and refactor; priced and shaped for engineering teams.

Discuss-before-acting was in the prompt — the review gate travels into autonomous lanes too ()

Slack + auto-PR-answering make it a team member, not a tool ('say hey Devin, this is a bug — it creates the branch, raises the PR') ()

It found NEW bugs while fixing assigned ones — autonomous scope creep in the good direction, still gated by the PR ()

Sentry-style integrations acknowledged: wire an MCP server and route the bugs ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

What keeps an autonomous fixer safe on a repo you care about?

The same pizza rules: its own branch, a PR you can read, CI checks, and merge as the human (or explicitly delegated) decision — autonomy inside version control, never around it.

05

The MVP lands imperfect: thin coverage, stale sources, and the feedback loop

First query: 'thin coverage — no usable sources found.' The freshly-built Superplexity fails on camera, and the recovery is the lesson.

The failure chain, kept in: the app runs, the first research query returns the thin-coverage default (working as specced!) because the DATABASE WAS EMPTY — no newsletters indexed yet. The fix is the standing pattern: copy the error, paste it to the executor ('this is the error I got — can you check?'), let it index the sources and retry. The working answer that follows has its own honest wrinkle: the sources are 'a little old — it says 4.6 while we are at 4.7' — retrieval freshness as a visible product property. His verdict calibrates expectations: 'still some improvements, but a decent start... a minimum viable product. It's in markdown — you'll have to say render it properly. Keep giving it feedback and improve it further.' And the edge-case humility: 'ideally the edge case should have caught that, but some slip through the cracks. You go back and fix.'

Worked example · from the session

Even the demo's content is meta: the query was 'Claude Code's latest capabilities' — the KB-shaped question asked of the KB-shaped tool.

Why it matters

Every build session in the corpus ends here; this one names the ending: MVP = the plan survived contact, the defaults fired correctly, and the remaining gap is fed back, not hidden.

People get this wrong

A live demo failing means the method failed.

The method's success IS the failure's shape: caught by a specced default, explained in English, fixed by one feedback cycle.

Most of the edge cases should have been caught before, but some slip through the cracks. Then you go back and fix that.
It's pretty decent because I made a very good plan first. Make a great plan, and anybody can execute it. Even in management.
For your projects

'Some edge cases slip through the cracks — go back and fix' is validate.py's philosophy in one sentence.

Go deeper

In one line: MVP honesty = ship the first working pass, let specced defaults handle the failure visibly (thin-coverage messages beat blank screens), debug by pasting errors to the executor, treat freshness and polish as feedback-loop items, and expect edge cases to leak — the spec catches most, the loop catches the rest.

The thin-coverage message IS the edge-case default working — a failure the spec made legible ()

Stale-source citations are a retrieval property to engineer, not a model embarrassment ()

'Both have their own place in the development life cycle' — his refusal to crown Windsurf or Devin extends to his own MVP ()

▶ Watch this taught:

Check yourself

Answer from memory first — the recall attempt is what makes it stick. Then reveal.

How do you tell a good MVP failure from a bad one?

A good failure is specified: the app says what went wrong in the product's own vocabulary (thin coverage, paywalled, conflicting). A bad failure is the blank screen Day 1 warned about.

Every concept, three clicks deep

The same concepts as a quick reference: the closed row is the glance, open is the study card, and every timestamp jumps into the recording.

01IDE vs autonomous agent: local Windsurf, cloud-sandboxed Devin, and free combinationIDE = local, collaborative, you-present (Windsurf/Cursor);

IDE = local, collaborative, you-present (Windsurf/Cursor); autonomous agent = cloud-sandboxed, task-complete, persists without you (Devin); pair them freely (70-80% feature overlap across VS Code descendants), routing supervised work local and long autonomous work to the cloud.

The testing-kitchen sandbox analogy is reusable for every isolation concept — branches, VMs, staging ()

JetBrains named as equally combinable — 'plug Claude Code or Devin into any platform' ()

Devin runs 'a mixture' of models underneath, not a single LLM ()

02Plan with Opus, execute with cheap: the two-model build ritualTwo-model ritual = frontier model + interview skill produces spec (human-readable) then plan (agent-readabl…

Two-model ritual = frontier model + interview skill produces spec (human-readable) then plan (agent-readable) in-repo; cheap adaptive models execute the plan by file reference; push back on recommendations, simplify on demand, and never pay frontier prices for implementation tokens.

The spec/plan split maps to audience: spec = verification surface for humans; plan = execution surface for agents ()

Windsurf's Opus lockout (BYO Anthropic key) is WHY the extension route exists — work around vendor walls with the shared folder ()

'We haven't written a single line of code' repeated like a mantra through 40 minutes of planning — the discipline is the demo ()

Design injected as data: a free design-system site's design.md pasted in for UI direction ()

03The Superplexity spec: curated-source bias, weighted blending, and budget-gated scrapingSuperplexity spec = curated-source retrieval (newsletters + tweets) with weighted blending, on-demand-only…

Superplexity spec = curated-source retrieval (newsletters + tweets) with weighted blending, on-demand-only paid scraping under a daily budget, six named edge-case defaults, Sonar-for-search via OpenRouter, thin-orchestrator architecture (SQLite FTS5, no vector store), auth deferred; produced by interview, verified in English, executed from the technical plan.

Weighted blend beats hard tiers because signal is probabilistic, not hierarchical — the agent's recommendation, adopted ()

The agent catches HIS ambiguity ('all fetching, or specifically the paid scraping?') — good specs are co-edited ()

'We don't need a vector store' is a scale-honest call: 20 articles into a long-context model beats infrastructure ()

Design direction arrives as a pasted design.md from a free design-system site — aesthetics as spec input, not afterthought ()

04Devin on existing code: review report, own branch, self-analyzed PRDevin workflow = repo in → sandboxed analysis → structured review report (bugs/quality/missing/improvements…

Devin workflow = repo in → sandboxed analysis → structured review report (bugs/quality/missing/improvements) → approved fixes on its own branch → PR with CI + self-analysis → merge; strongest on legacy migration and refactor; priced and shaped for engineering teams.

Discuss-before-acting was in the prompt — the review gate travels into autonomous lanes too ()

Slack + auto-PR-answering make it a team member, not a tool ('say hey Devin, this is a bug — it creates the branch, raises the PR') ()

It found NEW bugs while fixing assigned ones — autonomous scope creep in the good direction, still gated by the PR ()

Sentry-style integrations acknowledged: wire an MCP server and route the bugs ()

05The MVP lands imperfect: thin coverage, stale sources, and the feedback loopMVP honesty = ship the first working pass, let specced defaults handle the failure visibly (thin-coverage m…

MVP honesty = ship the first working pass, let specced defaults handle the failure visibly (thin-coverage messages beat blank screens), debug by pasting errors to the executor, treat freshness and polish as feedback-loop items, and expect edge cases to leak — the spec catches most, the loop catches the rest.

The thin-coverage message IS the edge-case default working — a failure the spec made legible ()

Stale-source citations are a retrieval property to engineer, not a model embarrassment ()

'Both have their own place in the development life cycle' — his refusal to crown Windsurf or Devin extends to his own MVP ()

Tools referenced

ToolCoverageMomentContext
WindsurfdemonstratedCascade implements the plan file with sub-agent-driven development on adaptive models; Claude Code runs inside via the VS Code extension
Devin (Cognition)demonstratedCloud-sandboxed review + fix of the model-council repo: report → branch → PR → self-analysis → merge; legacy-migration lane
Claude CodedemonstratedThe planner: Opus + superpowers brainstorming/writing-plans; the four-usage-limit war story motivates the split
superpowersdemonstratedObra superpowers — the interview-driven spec engine; install by pasting the GitHub link
OpenRouterdemonstratedSonnet 4.6 for synthesis, Sonar for search, keys in .env — 'I won't face rate limits because I'm using OpenRouter'
GitHubdemonstratedDevin's branch + PR + checks viewed live — Day 1's pizza mechanics operated by an agent
Wispr FlowdemonstratedDictation for the spec interview answers
PerplexityexplainedSonar (Perplexity's search model) replaces Google entirely — the better-Perplexity built on Perplexity
ApifyexplainedThe Twitter access lane vs the $200/month X API; budget-gated, on-demand only
VS CodementionedThe extension compatibility that lets Claude Code live inside Windsurf
CursormentionedCursor+Claude Code named as the equivalent IDE+agent pairing
Kimi (Moonshot)mentionedFree-tier lane recalled from Day 1's model ladder

Action items

Resources mentioned

Resources
  • docSuperplexity spec + plans (docs/superpowers, docs/plans)
  • docObra superpowers skill (GitHub)
  • docDesign-system prompt site
  • docScott Wu background
  • docAlumni Forge live + Catalyst C3 pitch

Extraction notes

This page was built from an auto-generated transcript, which garbles product and people's names. Those were corrected silently in everything above and logged here for transparency. The warnings flag claims that were true on the recording day but change fast.

Transcript corrections applied

The transcript saysThe trainer actually means
WinSoft / Winsorff / Binserv / WinZip / Windsors / build serve / WinserveWindsurf
Devon / Devlin / DevIn / Deviant / DevRel / daemon / dev inDevin
Scott Wu / Scott whoScott Wu (Cognition cofounder)
Cognition / CorporationCognition (Devin's maker; Windsurf's acquirer)
cloud code / CloudCo / plot code / Clorin / CloudCoreClaude Code
Oprah Superpowers / o b r aObra superpowers (the Claude skills repo)
SONNET 4.6 / 4.7as-heard Claude model versions at recording
styles dot referrer dot design / slides dot referrer dot comas-heard free design-system prompt site — name unverified
beehive / Beehive articlesBeehiiv (newsletter platform)
superplex tree / superplexitySuperplexity (the build)
sonar modelPerplexity's Sonar (search model, via OpenRouter)
SQLite FTS 5SQLite FTS5 full-text search
model console / model councilmodel council (his prior sprint build: multi-model debate answers)
firehouse (search the)firehose (full Twitter stream)
DeepVickyas-heard Windsurf code-understanding feature — name unverified
Sourcetias-heard GitHub-integrated review tool — unverified
e n v dot example sentinel.env.example sentinel (config guard mismatch bug)
widow power (newsletters get)veto power
crow coding(no) actual coding
the lip / the live / DilipDileep
seaside pool (launched a)CSAT poll

True on recording day — verify before relying