Learn to ship solo

Anthropic CPO Mike Krieger on using Claude Fable 5 for hands-off, overnight agentic work.

Two products, one founder, recurring revenue that makes people stop scrolling—what actually connects the dots between idea, pricing, and distribution?

• How do you choose a second app without killing momentum on the first?
• Which growth levers show up again and again before MRR compounds?
• When does building faster with AI help—and when does it mask a weak offer?

When an edge giant doubles down on the build tool most teams already run, the fight stops looking like framework vs framework and starts looking like who owns the whole ship loop.

• Why would a Workers-and-CDN company make Vite central to its story instead of pushing another framework?
• If hosting moats are built on build-plus-deploy bundles, what does a Vite-aligned stack threaten that Next-first paths don't?
• When headlines say a platform 'bought' an open tool, what should you verify before assuming your repo's defaults won't quietly nudge toward one host?

What if your AI didn't live in a browser tab—but sat on your desktop with permissions to actually run your workflows?

• Can you finish install and first real task in one sitting without guessing at API keys and paths?
• Where does a local desktop agent beat chat for file work, research, and light automation—and where does it still fall short?
• Which setup steps separate a reliable Hermes workflow from a one-off gimmick you never open again?

What if the sharpest engineers were the ones who refused heroic work—and what does that mean when AI can generate complexity faster than ever?

• Why do boring defaults often beat custom architecture in real user outcomes?
• Is skipping frameworks craft—or something else entirely?
• When AI writes code at scale, what does 'lazy' discipline actually look like?

What if your side projects could ship code, run jobs, and recover from failures while you sleep—and OpenAI Codex is only one piece of that puzzle?

• What does '24/7' really mean beyond a clever prompt—agents, cron, or something else?
• How do you keep Codex-built automation from drifting or breaking silently overnight?
• What's the minimum you need to own before a scaffold turns into a product people can rely on?

What if every extra instruction you add is quietly fighting the ones you gave earlier?

• Why might the model chase your latest tweak instead of the architecture you cared about on message one?
• What shows up in your diffs when context gets crowded with half-applied fixes and dropped edge cases?
• When does resetting the whole task beat another round of “just fix this one thing”?

Greg Isenberg argues the next giant market won’t look like another consumer app—and the customer on the other side of the checkout might not be human at all.

• What does it mean when AI agents become the ones with budgets and procurement authority?
• If your buyer is a machine, what has to change about pricing, trust, and how products get discovered?
• Where could the first $100B in 'agent economy' value actually accrue—apps, or the rails underneath them?

What happens when routing, server state, tables, forms, and the rest of the TanStack family have to share one codebase without stepping on each other?

• How do you slot seventeen TanStack libraries into a single app without turning it into dependency soup?
• Where does server-state management end and client routing or grid UI begin in one unified stack?
• Can you really adopt these pieces one at a time—or does the demo only work when everything is wired together?

When a blunt TypeScript-and-DX channel flags a take as deliberately provocative, what stack or AI-coding belief is about to get stress-tested?

• Does modern web tooling deserve the hype—or the backlash Theo is hinting at?
• What would you have to benchmark in your own repo to prove or kill his strongest claims?
• If assistants and agents come up, are they framed as accelerators or as traps for production teams?

What does it actually take to go from a vague app idea to roughly $30K a month when the founder says the path is idea, build, marketing—not a single lucky launch?

• How do you pressure-test an idea so people might pay before you build a feature-complete product?
• What belongs in a first version if the goal is proving demand, not impressing reviewers?
• How did distribution and messaging get treated from day one instead of after launch?

The benchmark everyone cites when they say an agent can fix real GitHub issues might not be the scoreboard for much longer—and the industry is already lining up what comes next.

• What actually breaks a benchmark when models start training on the test set?
• If SWE-Bench fades, what would a harder yardstick for repo work even measure?
• Are the tools you trust today ranked on metrics that still match how teams ship?

Anthropic just made a move—what does it actually change for Claude, your API bill, and the assistants you ship with every day?

• What is Anthropic pushing back against, and why should builders care right now?
• Could your stack—Claude vs Copilot vs Cursor—look different after this?
• Where does vendor chess end and something you can adopt this week begin?

A builder aimed at one painful gap in a category dominated by a billion-dollar incumbent—and walked away with a monthly revenue figure that sounds impossible for a “micro” product.

• What single job did they scope to instead of copying the whole platform?
• How did they prove people would pay before the product grew?
• Why can a narrow wedge beat feature parity against a giant SaaS?

Cursor offers a review skill pitched as “hardcore”—the open question is whether it can reliably flag sloppy agent-written code before it reaches your branch.

• What does hardcore review actually scrutinize when AI-generated diffs look plausible on a skim?
• How strict is it compared to a normal “review this” prompt inside the same Cursor workflow?
• For TypeScript and React day-to-day work, would you trust it as a pre-merge gate—or still need your own checklist?

A frontier lab behind Claude may have crossed a line peers still treat as years away—and that changes how you'd pick an AI coding stack.

• What early signals suggest Anthropic could be profitable while other frontier labs are still burning cash?
• If it's true, how might Claude's roadmap, pricing, and rate limits shift for developers betting on agents and APIs?
• Why does a solvent frontier vendor matter more for your long-term stack than the next model benchmark?

A senior TypeScript builder’s stack for coding with AI didn’t stay the same—what shifted when autocomplete stopped being the whole story?

• Which stage of AI assistance actually changed his day-to-day the most—and what did he stop trusting models to own?
• If agent-style multi-file edits are in play, what scoping and review habits keep quality from sliding?
• Does picking the right editor integration and repo context beat swapping models for repeatable output?

What if the first paint stayed fast because React didn’t have to hydrate the whole page at once?

• What exactly can TanStack Start defer hydrating without breaking forms and navigation?
• Does deferred hydration actually move Time to Interactive—or mostly shift work to later?
• Which UI boundaries are safe to hydrate late, and which ones can’t wait?

Matt Pocock’s /grill-* slash skills look like one-click fixes from the menu—until nine routine misreads of scope, inputs, and workflow turn structured reviews into wasted runs.

• Why do people treat /grill-* like a generic ‘fix my code’ button when the skills assume specific file context and goals?
• How do you know which grill variant matches review versus refactor versus explain—and what goes wrong when they look interchangeable?
• What breaks when you skip the skill’s steps or throw huge unscoped diffs at a playbook that was designed for narrow scope?

What had to be true on day one for revenue to hit thirty thousand a month by day thirty-five?

• Was it an audience, a product, or a channel that moved first?
• Does the thirty thousand mean the same thing they’d claim in the fine print?
• Which single loop did they refuse to split before scaling spend?

Seven figures in a niche nobody posts about—what makes the economics work when there’s zero hype to lean on?

• Which deliberately dull market category can still clear $1.7M a year—and why is competition often thinner there?
• What offer, pricing, and retention shape looks repeatable at that revenue—not a one-off launch?
• When the product feels unsexy next to AI buzz, what actually wins: customer clarity, distribution, or operations?

Matt Pocock keeps returning to one slash command—and the moment it belongs in your workflow is the opposite of when most people reach for a new skill.

• What should a /handoff actually contain before you close the tab or swap agents?
• Why does naming it a first-class command change whether you use it every time?
• What goes wrong in the next session when the handoff contract is too thin?

Greg Isenberg claims nine opportunity buckets are bigger than everything else founders are chasing right now—and AI is only one lane on the board.

• Which of his nine bets still has room for a solo builder without a massive fund?
• Where do B2C and mobile actually overlap with AI in his framing—and where do they diverge?
• How do you turn a macro trend shortlist into a wedge you can validate before writing code?

If your coding assistant wakes up blank every turn, you're not missing a feature—you're fighting how real work actually unfolds.

• Why do stateless agents keep re-learning the same repo quirks—and who pays for that in tokens and mistakes?
• When should an agent remember a decision versus look it up in the codebase—and can RAG alone bridge that gap?
• If memory can contradict your current branch, is forgetting the feature you need most?

Matt Pocock quietly retired /grill-me from his coding stack—and whatever he swapped in could reshape how you pick AI defaults for shipping code.

• What made interrogation-style prompts the wrong fit for day-to-day implementation?
• Which pattern does he reach for when the goal is code on disk, not a grilling session?
• Is your favorite slash command adding friction you never measured?

What if the harshest PR comments never had to happen because you already caught what the bot would flag—on your laptop?

• Why run CodeRabbit locally before you push instead of only on the hosted PR?
• What kinds of issues can a pre-submit AI pass actually remove from review threads?
• Where does machine review stop and human judgment still have to own the call?

Anthropic’s new “dedicated monthly credit” sounds like a bonus—until you map it against what you could actually run last month.

• What changed in the buckets behind Claude Code versus API usage?
• Why might the same invoice line mean fewer Opus-class sessions than before?
• Which surfaces quietly drain the pool you thought was separate?

What if one person could run an AI agent business past seven figures—without hiring a team first?

• What’s the narrow wedge most solo operators pick before they expand offerings?
• How do $1M+ solo agent shops actually mix pricing—retainers, builds, and usage?
• What has to be in the contract before an agent is allowed to act on a client’s behalf?

Your AI editor just shipped a batch of slash commands—do you actually know what each one is supposed to do?

• What should you hand off to the agent so context doesn’t die between sessions?
• When is /prototype the right move instead of jumping straight into production code?
• What kinds of writing work are the /writing-* skills meant to cover—and how is /review different from a normal critique?

One instruction and one agent action might replace the usual marathon of chat tweaks—if you know what to bundle into that call.

• What do you specify up front so metrics, chart types, filters, and empty states come back as one dashboard—not scattered cards?
• Why can delegating “build dashboard” to a single named tool call beat a long chain of refinement messages?
• What has to happen after the first scaffold lands before APIs, auth, and performance are production-ready?

When hundreds of tickets feel immovable, what if one slash command could turn the pile into a queue you actually drain?

• What does `/triage` actually run inside your editor—and why does it beat scrolling the board ticket by ticket?
• Which rubric sorts signal from noise so AI coding gets scoped tasks instead of one giant dump?
• How do you batch similar backlog work so throughput spikes without living in context-switch hell?

What if your web app could run its own agent on your UI and data—without signing up for another chat API subscription?

• How do you wire MCP-style tools into a browser app so the assistant isn't just a paid sidebar?
• Can an embedded agent actually change application state, or only talk about it?
• When they say "free," is that local runtime, open source, or something else you have to verify in the walkthrough?

Testing Codex CLI's new /goal 'Ralph loop' — keep one objective running autonomously until done.

What if your codebase kept shipping while you were literally away from the keyboard—and you could steal the whole playbook from an open repo?

• What does an ‘AFK software factory’ actually wire together so agents don’t need you live?
• Which gates and checks does Matt treat like CI before agent output ever touches main?
• What’s in the open-sourced layout that turns one-off AI chats into a repeatable factory?

What if one repeatable skill could dig a real repo out of months of low-quality AI output without a full rewrite?

• How do you tell duplicated logic and comment-noise from “normal” tech debt when an LLM filled the codebase?
• What does a focused de-slop workflow actually run before merge so slop doesn’t creep back in?
• Can agents plus human gates shrink the cleanup into small PRs instead of one scary refactor?

Server Components let you cache some of a page at the edge while other slices stay per-request—where you draw that line decides whether visitors get speed or the wrong data.

• Which parts of a React Server Component tree can you cache for every visitor without leaking personalized UI?
• How do cache boundaries and revalidation work when only some segments are static on the same route?
• Can you keep client interactivity on islands without forcing the entire RSC output out of the CDN?

TanStack Start offers more than one path to server rendering—how do you pick among them without drowning in docs?

• Which of the five SSR/RSC patterns fits a stale-while-revalidate API versus a fully dynamic storefront?
• Where do React Server Component boundaries actually land in a Start route tree?
• What changes on the server versus the client when you swap from classic SSR to an RSC-first setup?

Your AI pair programmer can ship answers in seconds—so what still has to happen before any of it belongs in production?

• Why does a confident, fluent reply still deserve the same skepticism as an anonymous Stack Overflow paste?
• What should every generated diff pass through before it earns a merge?
• Which kinds of decisions are unsafe to outsource no matter how good the model sounds?

Claude Code’s /init just got a refresh—does it finally seed your repo cleanly, or do you still end up fighting the agent on paths, scripts, and conventions?

• What actually changed in the new /init flow compared to what you already run in your projects?
• On the same real repo, does before-and-after show fewer wrong guesses—or more back-and-forth after bootstrap?
• When should you trust /init versus writing your own rules and checked-in agent instructions?

From vague idea to shipped code—what does agent-assisted development actually look like when the feature is real?

• Which decisions stay with you when Claude Code is pair-programming on a scoped feature?
• What order of steps turns agent chat into something you can run and verify in your repo?
• When does treating the agent like open-ended “fix everything” fail—and what workflow replaces it?

Matt Pocock won’t open Claude Code until five specific habits are in place—most developers treat them as optional.

• Which daily setup keeps stack rules and hard nos attached to every session without re-pasting?
• How do you scope agent work so “done” means tests or typecheck—not just a convincing reply?
• When does guessing about APIs become unacceptable—and what do you plug in instead?

Most teams treat the model like a black-box coder—Matt Pocock’s title promises a seven-step order where human gates and LLM bulk work actually belong.

• What has to be locked before you let the model generate piles of code?
• Which phases are for judgment and constraints versus implementation—and how tight should the generate–read–correct loop be?
• Why is verification a mandatory gate instead of optional polish after the model says it’s done?

Matt Pocock opens a messy real repo and asks why your assistant keeps proposing changes that don’t compile—and what you’d change before trusting an agent near production.

• Why does a layout that humans tolerate leave models guessing at APIs and types?
• What guardrails turn autonomous edits from scary experiments into something you’d merge?
• Which small context choices matter more than dumping the entire repository into chat?

Your project notes tell Claude Code which CLI to use — so why does it still reach for the wrong binary when the pressure is on?

• Why does another paragraph in CLAUDE.md fail when you need pnpm instead of npm every single time?
• What is the difference between documenting a stack rule for humans and actually wiring execution so the agent’s default path is the one you want?
• When the model or plugins update overnight, what do you re-check so CLI choice does not silently drift again?

That first Claude Code ritual on a fresh repo might be doing more harm than a careful blank slate.

• What is Claude’s `/init` really optimizing for when the repository is still empty?
• Why can one bulk scaffold pass burn context before you’ve even validated the problem?
• When does skipping auto-initialization keep your first AI diff small enough to actually review?

Classic TDD might be the sharpest leash for a coding agent that loves to guess your APIs.

• What if the failing test—not a giant prompt—is what tells Claude Code what to build?
• Can red–green–refactor catch wrong assumptions before you merge agent-written code?
• Who owns success criteria when the agent goes green and you still need a clean refactor?

One Git checkout for you—and a separate sandbox for every Claude task—might be the cleanest way to run parallel agent work without stepping on each other.

• What happens when two Claude sessions edit the same repo in one folder—and how does a worktree sidestep that?
• How do you test and merge agent changes while your main branch stays untouched?
• Is “one task, one worktree” actually practical for daily Claude coding, or overkill?

A senior TypeScript educator who dismissed coding assistants describes the one workflow that finally made AI feel reviewable instead of reckless.

• What was he afraid would happen the moment an agent touched his repo?
• Which step comes before any file changes—and who gets to veto it?
• Can you stay skeptical of autopilot and still get real value from AI-assisted coding?