Learn to build with AI

First Framework Hell, then Tutorial Hell - Matt Pocock says AI coding just invented its own version, and installing more skills is exactly how you end up in it.

• What tips a helpful skill library over into Skill Hell?
• How do you tell a skill you need from a skill that just feels productive to install?
• How many of your installed skills have you actually used this week?

Matt Pocock says most of the docs in your repo are actively hurting your agents - and the ones worth keeping share one trait almost nobody checks for.

• Which docs make an agent worse at your codebase, and why do they rot faster than code?
• What is the one property a doc must have to survive Matt's delete pass?
• Could you delete half your docs folder tomorrow and trust the code to speak for itself?

Matt Pocock admits the always-on loop of prompting, reviewing and re-steering agents is wearing him out - and his fix is not another tool.

• What exactly makes agentic coding more draining than writing the code yourself?
• Which habit does Matt say turns review fatigue back into flow?
• Is your own AI workflow saving you time or just relocating the exhaustion?

Skills, agents, harnesses, loops, effort levels - Matt Pocock pins down the vocabulary of AI coding, and a few terms almost everyone is using wrong.

• Which two AI-coding terms get conflated most often, and what breaks when they are?
• Where does a harness end and an agent begin in Matt's taxonomy?
• Could you define the words in your own team's AI workflow without hand-waving?

Theo's follow-up on the Codex fold-in asks the sharper question: OpenAI spent a year building Codex into THE developer brand, then erased it - on purpose.

• What does killing a winning developer brand say about where OpenAI thinks the money is?
• How does ChatGPT Work change who Codex is actually for?
• Would you bet your workflow on a vendor that rebrands mid-sprint?

Greg Isenberg walks through how people are turning loop engineering - the technique replacing prompt engineering - into actual paid work.

• What does a money-making agent loop look like beyond the /goal-on-repeat meme?
• Which loop-engineering services are clients paying for right now?
• Could you package the loops you already run into something billable?

Matt Pocock demos /wayfinder live on a real codebase - the new v1.1 skill that decides where your agent should go before it writes a line.

• What does /wayfinder actually produce before /implement is allowed to touch code?
• How does the live run recover when the agent's first exploration heads the wrong way?
• Would you trust a wayfinding pass to pick the entry point in your own repo?

Nate Herk wires Claude Code into Clay and turns lead generation from a grind into something he calls actually fun - the interesting part is what Claude Code does that Clay alone never could.

• What does Claude Code add on top of Clay that changes the lead-gen workflow?
• How much of the pipeline ends up automated, and where does a human still steer?
• Would you trust an agent to touch your outbound pipeline, or is lead-gen too costly to get wrong?

Theo finally sits down with GPT-5.6 for a full review - and the verdict he lands on is not the one his week of daily-driving it seemed to be setting up.

• Where does GPT-5.6 actually beat the models Theo was using before, and where does it quietly fall apart?
• What does his review say about picking a daily-driver model for coding versus chasing every new release?
• Would his verdict change which model you reach for on your next real project?

Nate Herk spent six hours teaching Claude Code to people who have never written code - and the course structure reveals what he thinks non-coders get wrong on day one.

• What does Nate cover first when the audience has zero coding background?
• Which Claude Code habits does the course drill that most tutorials skip?
• Could someone on your team who has never coded actually ship something after six hours?

Theo says Codex is dead - not killed by a rival lab, but by something inside OpenAI's own lineup, and the fallout hits anyone who built their workflow on it.

• What actually killed Codex, and why does Theo call the death unexpected?
• What does OpenAI's handling of it signal about betting on any one vendor's coding agent?
• If your daily workflow ran through Codex, what would you migrate to first?

Greg Isenberg makes the contrarian call of the week: Grok 4.5 matters more than Claude Fable 5 - and his reasoning has less to do with benchmarks than with who gets to use it.

• What makes Grok 4.5 a bigger deal than Fable 5 in Greg's framing?
• How much of the argument survives once Fable 5's credit gating and rollout drama settle?
• Would you switch your stack over access and price, or does raw capability still win for you?

Theo maps the history of AI agents into distinct eras - and argues we just crossed into a new one that changes what an agent even is.

• What separates each era of AI agents, and what actually triggered the transitions?
• Which of today's agent tools does Theo think belong to an era that is already over?
• Are you building on the current era's assumptions or the last one's?

Theo had early access to gpt-5.6 and calls Sol world leading at computer use - yet the way he actually splits work between it and Fable 5 is not what the benchmarks suggest.

• What did gpt-5.6 Sol do that made Theo use it 100x more than previous OpenAI models?
• Which coding tasks does he still route to Fable 5 even with Sol available?
• Would early access change your verdict, or do you only trust a model after a month in your own repo?

Nate Herk ran GPT 5.6 Sol head to head against Fable 5 within hours of the rollout - and the winner flips depending on which kind of task you hand them.

• Which tasks did GPT 5.6 Sol win outright, and which did Fable 5 keep?
• Does Sol's lower price change the math even where Fable scores higher?
• Would you switch your default coding model on day-one tests, or wait for a month of real use?

Greg Isenberg got into GPT 5.6 Sol on launch day and walks through how he actually uses it - including the workflows where he says it beats every model he has tried.

• Which everyday workflows does Greg move to Sol first, and why those?
• How does he prompt Sol differently from Claude to get agent-grade output?
• Would launch-day hype move you, or do you wait for the first real teardown?

Theo did not want to like the new Grok model - the title says 'oh no' for a reason - but his testing pushed him somewhere he clearly was not planning to go.

• What did the new Grok model do in Theo's testing that earned the reluctant 'oh no'?
• Where does it land against the coding models he already recommends?
• Would a strong Grok showing actually change what you code with, or is the ecosystem lock-in too strong?

Nate Herk handed Claude Fable 5 a single prompt and let it build an entire business - the question is how much of the result was the prompt and how much was the model.

• What did the one prompt actually contain, and what did Fable 5 produce from it?
• Where did the build break down and need a human to step back in?
• Would you run your next idea through one giant prompt, or is that a demo trick?

Matt Pocock ships v1.1 of his skills collection with five new slash commands - and the split between /research, /implement and /to-spec hints at how he thinks agent work should be staged.

• What does /wayfinder do that a plain prompt cannot?
• Why separate /to-spec from /to-tickets instead of one planning command?
• Would you adopt someone else's slash-command taxonomy, or grow your own from scratch?

Theo argues some products should ship as a markdown file instead of an app - and the skills-and-agents wave makes the idea less crazy than it sounds.

• What kind of product actually works as a plain markdown file an agent can read?
• How do skills and SKILL.md files turn documentation into distribution?
• Would you pay for a product that is literally a text file if it saved your agent hours?

Theo spent weeks with Fable 5 before publishing a guide - and his setup breaks with how most developers configured Claude Code on day one.

• Which default Claude Code settings does Theo say actively hold Fable 5 back?
• Where does Fable 5 need less steering than Opus - and where does it need more?
• Would you rebuild your daily workflow around one model's quirks, or keep it model-agnostic?

Theo breaks down Anthropic's Sonnet 5 drop the same week Fable stole the headlines - and argues the quieter release might be the one that actually changes your daily coding.

• What did Anthropic actually change in Sonnet 5 that lets it approach Opus-level coding for a fraction of the cost?
• Why does Theo think this release matters more than the flashier Fable 5 headline from the same week?
• Would you switch your default coding model the same day a cheaper near-Opus option drops?

Nate Herk digs into how Anthropic's own engineers prompt Fable 5, and their habits look almost nothing like the prompt guides circulating on X.

• What do Anthropic engineers put in a prompt that most Fable 5 users leave out?
• Which popular prompting tricks do they skip entirely?
• Would rewriting your prompts the insider way actually change your output quality?

Theo says Fable and Sonnet 5 landed on the same day - one of them is the model Anthropic wants you using every day, and it might not be the one you think.

• Which of the two new Claude models is actually built for your daily coding loop?
• What changed about Sonnet 5 that makes Theo call it the more interesting release?
• Would you switch your default coding model the same day it ships?

GPT-5.6 just shipped, and Theo says there's a catch that keeps it out of reach for the people who'd actually want it in their coding stack.

• What is actually blocking access to GPT-5.6 right now?
• How does Theo think GPT-5.6 stacks up against the Claude models that shipped this week?
• Would you wait it out, or route around it with a different model today?

Karpathy says the next paradigm shift in AI coding is already visible - and Theo thinks most developers are still building for the one before it.

• What does Karpathy specifically mean by a paradigm shift, and how does it differ from what most AI coding tools are currently optimized for?
• If the shift is already underway, why do most coding workflows still look the same as they did a year ago?
• How would you know if your current AI coding habits are already out of date with where the field is heading?

Greg Isenberg walks through exactly how he got GLM 5.2 running - and the reason he bothered setting up a model most developers have never heard of might change your shortlist.

• What does the GLM 5.2 setup process actually require, and is there anything that trips people up on the first pass?
• At what point in a project would you reach for GLM 5.2 over the models already in your stack?
• Would you add a less-known model to your daily workflow if the performance numbers alone justified it?

Theo picks a fight with one of the oldest habits in software development - and the reason copy-pasting is worse in 2026 than it ever was is the part that might sting.

• What changes about copy-paste as an anti-pattern when AI can generate the same code on demand instead of you searching for it?
• How do you build institutional knowledge in a codebase when the shortcut everyone reaches for leaves no trace of why a pattern was chosen?
• Is your reflex to copy a snippet the reason your AI-generated code keeps drifting toward patterns you never intended to own?

GLM 5.2 runs inside Claude Code at a fraction of frontier-model pricing - whether the output quality survives the discount is the part worth watching.

• How close does GLM 5.2 actually get to frontier models on real Claude Code tasks?
• What do you trade away when your daily coding model suddenly costs 5x less?
• Would you trust a non-Anthropic model as your default driver in Claude Code?

Theo's reaction to the industry pivoting toward writing loops is half disbelief, half buy-in - and the unresolved question is whether this is a real shift or just new packaging on old prompting.

• What changed in the tooling that suddenly makes 'writing loops' the recommended way to drive an agent?
• Where do agentic loops genuinely outperform a careful single prompt, and where is it hype?
• Would you restructure how you use Claude Code around loops, or wait for the dust to settle?

Theo argues you should stop writing one-shot instructions for Claude Code and start writing prompt loops - the catch is that the loop only pays off if you get one specific part right.

• What turns a prompt into a loop instead of a single instruction, and where does the agent actually re-enter it?
• Why do one-shot prompts quietly stall on multi-step work that a loop would finish?
• Is the way you prompt Claude Code today leaving completed work on the table you never noticed?

Greg Isenberg compresses the case for agentic loops into 60 seconds and claims they are where prompting is headed - what he leaves out is whether that holds once the task is bigger than a demo.

• What separates an agentic loop from just running the same prompt again by hand?
• Which kinds of work actually compound when you loop an agent, and which just burn tokens?
• If you adopt loops, what part of your current prompting habit do you have to give up first?

Theo calls Anthropic's newest usage rules 'horrible' - the part worth watching is which everyday Claude Code workflows the restrictions quietly make more expensive or slower.

• What exactly changed in the new limits, and who feels it first - light users or heavy agent runners?
• Which workflows hit the ceiling soonest under the new caps?
• Is your current Claude Code usage about to cost more or stall, and have you actually checked?

Anthropic just put its most powerful model, Claude Fable 5, in public hands - and Theo digs into the catch buried in how it quietly hands some prompts back to Opus 4.8.

• What makes Fable 5 a step up from Opus 4.8 for real coding and agent work?
• Which prompts silently fall back to a weaker model, and how often does that actually happen?
• At $10 in and $50 out per million tokens, is Fable 5 worth it for what you actually run?

Greg Isenberg says most people are using Claude Fable 5 wrong - and the fix is less about better prompts than about handing it the kind of long-horizon work it was actually built to run.

• What does Fable 5 do well that people keep wasting by treating it like an older model?
• How should you structure a task to use its longer autonomous runs instead of fighting them?
• Are your current prompts quietly capping Fable 5 at a fraction of what it can do?

Theo connects the dots that Claude Fable is the model shipped under the 'Mythos' codename, and lands on a verdict he is rarely this direct about.

• What does Fable actually do better in real coding work, not just on benchmarks?
• Where does Theo think it still loses to the competition he normally favors?
• After his takes on past releases, does 'really good' from Theo change what you reach for?

Anthropic CPO Mike Krieger walks Every through how Anthropic itself uses Claude Fable 5 - and the internal workflows rarely match the tidy advice handed to everyone else.

• How does the team that builds the model actually use it day to day?
• Which habits does Krieger say externalize well, and which only work inside Anthropic?
• Are you using Fable like a power user or just a faster autocomplete?

Nate Herk wires Claude Fable into a personal second brain - the open question is whether a frontier model can hold your notes, context and recall without becoming a mess you stop trusting.

• What is the actual setup that turns Fable from a chat box into persistent memory you query?
• Where does it beat a dedicated notes app like Notion or Obsidian, and where does it fall short?
• Would you hand your scattered notes to a model and rely on it to surface the right one later?

Greg Isenberg puts the 'AI agent loop' on trial - genius or hype - and refuses to settle it until you see where the loop earns its keep and where it just spins.

• What is the actual mechanism of an agent loop, stripped of the buzzword?
• Which real tasks does looping make dramatically better, and which does it not touch?
• Before you build around agent loops, can you tell where yours would add value versus burn time?

Nate Herk says Claude's 'Mythos' is finally here - but the interesting part is what the codename actually unlocks versus the hype that preceded it.

• What is Mythos actually shipping as, once the branding is stripped away?
• Which Claude Code workflows change the day you switch to it?
• Is it worth rebuilding your current automation setup around, or a wait-and-see?

Nate Herk claims most people build Claude subagents wrong - and the difference between the 1% and everyone else is not the prompt you would guess.

• What separates a subagent that actually offloads work from one that just adds overhead?
• How should you scope and hand context to a subagent so it does not lose the plot?
• Are your current subagents quietly slowing the main agent down instead of speeding it up?

Greg Isenberg claims you can go from AI-curious to genuinely AI-native in under an hour - the question is which habits he says you must drop, not just which tools you add.

• What separates someone who is 'AI native' from someone who just uses AI tools occasionally?
• Which old workflows does he say to abandon outright to make the jump stick?
• After 60 minutes, what would you actually do differently tomorrow versus go back to old habits?

Edward Donner wires Claude Code, agentic RAG, and MCP into a single working build in one video - the open question is what actually holds together once all three run in the same loop.

• How do agentic RAG and MCP divide the work, and where does one hand off to the other?
• What breaks when retrieval, tools, and the agent loop all fire inside one Claude Code session?
• Could you assemble this stack for your own project, or does it only behave in a controlled demo?

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?

Anthropic just put Claude Code agents on a meter, and Daniel Jindoo walks through what metered agent runs do to the way you've been letting them work unsupervised in the background.

• What does putting agents 'on a meter' actually charge for that used to feel free?
• How does metering change whether you fire off long autonomous agent runs?
• Are your background Claude Code agents about to run up a bill you never tracked?

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?

Nate Herk credits a single Claude Code skill with a 10x jump in his projects - and pointedly does not name it in the title.

• Which one skill is doing the heavy lifting, and why this one over the obvious picks?
• What was breaking in his workflow before it that the skill quietly fixed?
• Is the same bottleneck slowing your projects without you having named it yet?

Nate Herk ran through every Claude Code feature and narrowed it to 12 keepers - the list is more surprising for what he left off than what made it.

• Which 12 features earned the cut, and which popular ones got dropped?
• What was his bar for 'best' - daily use, time saved, or something else?
• Are you leaning on features he tested and quietly rejected as not worth it?

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?

Nate Herk argues most Claude Code setups are static when the real unlock is workflows that decide their own next step - and that gap is where projects stall.

• What makes a workflow 'dynamic' versus a fixed chain of prompts you wrote once?
• How does the agent choose its next action without you scripting every branch?
• Are your current automations rigid in a way that breaks the moment the input changes?

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?

Codex CLI just added a /goal command, and AI Coding Daily asks whether it is OpenAI quietly shipping the 'Ralph loop' - an agent that keeps cycling on one goal until it is actually done.

• What does /goal do that a normal Codex prompt does not, in practice?
• Is this really the Ralph loop pattern, or just an autonomous-mode rebrand?
• Would you trust it to grind on a task unattended without burning tokens or going off the rails?

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?