On day two, mid-task, it read my CLAUDE.md and caught it teaching the exact pattern my own quality gate bans. I hadn’t asked for a review. It hit the contradiction and flagged it on its own.

That file is 320 lines. The knowledge layer behind it is 166 files, around 300k words of rules my agents follow every day. And every one of those rules was written by and for a weaker model.

This guide is what I did about that, plus everything else from 7 experiments and 1,000+ timed runs in Fable 5’s first four days.

One honest note before we start. I published my launch-day numbers on day two, then retested everything at 20 rounds per cell on a single build. Two headline claims didn’t survive. They’re corrected below with the old numbers named, not quietly replaced.

We’ll cover:

• What changed, what it costs, and the migration gotchas that bite first

• The effort dial and the “Fable is slow” complaint at 20 rounds per cell, including what flipped

• What a real finding costs: Fable bills 2x per token and still wins the audit math

• When your model silently swaps mid-conversation, and why the swap sticks

• The audit prompt to run before giving Fable real work, and the migration workflow behind the paywall

• Objectives, not tasks: /goal patterns (paid)

• My depth-10 nesting experiments, the real cost multiplier, the decision rule (paid)

We won’t cover: API migration fine print, benchmark-by-benchmark analysis, or anything I haven’t run myself.

1. What Actually Changed

According to Anthropic, Fable 5 is “a Mythos-class model that we’ve made safe for general use. Its capabilities exceed those of any model we’ve ever made generally available.”

They built a model they don’t fully release. Mythos 5 stays limited-access, available to trusted partners. Fable 5 is the version of it you’re allowed to have.

That framing matters more than any spec row, and we’ll come back to it in Section 3.

Fable plugs in wherever Opus 4.7/4.8 did, with a few breaks that will bite you if you migrate blind:

Three migration gotchas hiding in that table:

1. You can’t turn thinking off. Pipelines that set thinking: disabled for speed get a 400 error. The effort dial survives. Zero doesn’t.

2. Temperature is gone. If your eval suite sweeps sampling settings, those configs fail on Fable.

3. Until June 22, your API keys can’t reach it. Subscription surfaces only (Claude Code, Cowork, the apps). Plan your team’s testing window accordingly.

1.1 Fable 5 effort dial, measured

Instead of taking the docs' word for it, I measured. First at 5 rounds on launch day, then at 20 rounds per cell on day four:

What held from launch day:

• Below max, the dial barely moves. Thinking is adaptive. The model ignores budget it doesn’t need.

• Correctness never moved. On a hard math puzzle with a checkable answer, every effort level got it right, with the same method. The extra seconds bought re-verification and caveats, not better answers.

What’s new at n=20: max is where Fable and Opus separate the most, 60.8 vs 49.0 seconds at the median. And that gap moved between builds. The top of the dial is the unstable part.

One gotcha worth this whole section. Pass a typo to --effort and the CLI silently falls back to your configured level, not the model default. I ran --effort xyz 20 times as a control: median 17.6 seconds, right on top of xhigh (18.5s), nowhere near high (13.6s).

So check your settings before you benchmark anything. My machine had xhigh persisted, which means every flag-less run I timed ran both models at xhigh. Matched, so the ratios stand. But the honest label on my charts is “matched effort,” not “out-of-box default.” The documented default is high on both Fable 5 and Opus 4.8.

The practical setting hasn’t changed: default to high. Dialing down buys back a few seconds, not different answers. Max should stay a rare exception. It’s now the least stable level, too.

Subscribe now

1.2 Fable 5 speed question, retested

The loudest day-one complaint after the classifiers: “Fable is slow.” One widely shared review called it a crawl, “even on simple tasks.”

I couldn’t find numbers, so I made my own. 320 timed runs, both models at matched effort, stream-level timestamps, exact token counts, outliers kept:

What held:

• The starting pause is real. First visible activity at a median 6.7 seconds vs 4.3 for Opus. That 2.4-second blank screen is my bet for where the “it crawls” feeling comes from.

• The trivial tax is modest. On one-shot questions, Fable averaged 1.48x Opus wall-clock. Every answer correct from both models.

What flipped on the retest:

• “Denser, not slower” didn’t survive. On launch day, Fable used about 40% fewer output tokens on the same math problem and finished sooner. At n=20 the token gap shrank to 8%, and Fable finishes 1.5x behind.

• Neither did “the gap vanishes on real work.” Across 20 heavy multi-file audits, the median tax is 1.29x (best pair 0.92x, worst 1.70x). Two of twenty beat Opus outright. The tax flattens with task size. It doesn’t vanish.

What didn’t move: correctness. All 240 graded answers correct, from both models.

So the verdict is narrower than the discourse: budget a short pause at the start of every exchange, accept a 1.3 to 1.5x time tax, and ask what the extra time buys. Section 2 prices exactly that.

Subscribe now

1.3 The benchmarks

Anthropic’s official chart covers these better than any table I’d retype:

Two things the official chart won’t tell you:

• The row that tells you what tier this is: FrontierCode Diamond, the hardest unseen problems in the set, where Fable more than doubles Opus 4.8 (29.3 vs 13.4) and runs 5x GPT-5.5:

  

• And one honest footnote from the system card: Fable’s published scores already include its production safeguards, which is why some rows run slightly below Mythos.

2. What a Real Finding Costs

Fable bills 2x per token. Here’s what that turns into when the task is finding problems, not answering questions.

I ran 60 audits of the same three style-guide files, 30 per model. Every run was metered from session traces and validated to the cent against the CLI’s own billing:

Three prices for the same work:

• Per audit: 2.5x. $2.93 vs $1.17 at the median. Wider than the price sheet, because Fable also writes more.

• Per finding: 1.25x. Fable surfaces a median 14 distinct findings per report vs Opus’s 7. So $0.21 vs $0.17 each.

• Per the bug that matters: 0.25x. One planted issue required reading two files against each other. Fable caught it in 20 of 30 audits. Opus caught it in 2.

That last row is the one your invoice feels. Expected spend per deep catch: $4.40 with Fable, $17.55 with Opus. The expensive model is 4x cheaper!

It’s not “Fable finds everything,” though. A same-file style clash got caught more often by Opus, 16/30 vs 12/30. Depth and breadth are different axes.

For PMs: price the outcome, not the tokens. Per token, Fable costs 2x. Per deep finding, a quarter. Whoever frames the unit wins the budget conversation, and that’s as true for your product’s pricing page as it is for your AI bill.

3. The Safeguard Layer Most Coverage Missed

3.1 The visible layer: routing

Fable 5 ships with classifiers that screen for high-risk domains. When a query trips one, the session is routed to Opus 4.8 instead, and you get a notification. Anthropic puts it at ~5% of sessions.

My own experiments with subagents got capped, too:

It doesn’t fail the query. It hands it to a different model, on purpose, and tells you. The capability ceiling and the safeguard layer are different things, and knowing which one you hit changes what you do next.

And the reroute sticks. Per the Claude Code docs, the session continues on Opus after a flag. /model fable takes you back, but if the trigger is still in your context, the next request just bounces you again. I learned that one live. My first read was “you can’t switch back.” The docs’ version is more precise: you can switch back, you just can’t stay.

The classifier reads your workspace, too. CLAUDE.md content and git status ride along on the first request. So a repo full of security or biology material can reroute a session before you’ve typed anything unusual.

Why does the screen exist at all? According to Anthropic, “Mythos-class models have reached a threshold where they present significant risks.“ The example they give: these models “excel at discovering and exploiting software vulnerabilities,” enough to make cyberattacks “substantially easier and cheaper to commit.”

There’s also a second, invisible layer. Per the system card’s Section 1.5, requests targeting frontier LLM development itself don’t reroute. They get quietly degraded, with no notification, on ~0.03% of traffic. Unless your team pretrains models, you’ll never hit it. Researchers are furious anyway (Elie Bakouch’s “very very sad for the research community“), and the precedent stands: the model you bought can be tuned down by topic, silently.

3.2 What this means for your team

Four practical notes from the first four days:

• Expect occasional routing, especially if your work touches security, healthcare, or biotech. Anthropic admits it (Claude Code’s Boris Cherny: “We know the classifiers are trigger-happy, and are working on improving it“). The notification is your signal: you did nothing wrong, and the floor is “merely Opus 4.8.” For security audits, the supported path is the built-in /security-review command. Also see my /security-review-static, which inspects the full solution, not just the diff.

• Two diagnostics worth knowing. For example, claude --safe-mode starts a session without your customizations, so you can check whether your own files are the trigger. And /config has a toggle that asks before switching instead of switching silently.

• Once flagged, decide fast. Treat the session as an Opus session or start clean. Don’t fight the classifier mid-context.

• The API behaves differently. When per-token access opens June 22, a tripped classifier blocks the request and returns a structured refusal category. There’s no automatic fallback by default. Server-side fallback to Opus is opt-in. The same applies to claude -p scripts today: non-interactive runs get a refusal, not a reroute.

The safeguard is worth copying: it swaps your model mid-session for safety. We can swap on purpose, for cost. Keep a cheaper model as your default and bring in Fable 5 only for the one call that needs it. Section 8 has what that costs.

Side Note: On September 1 we’re launching the 3rd edition of Claudathon. It’s a hands-on program to learn by building and shipping production-ready apps with embedded agents.

Before the cohort you should get familiar with the basics: VS Code, CLAUDE.md, skills (we provide the materials).

Early bid discount: https://go.productcompass.pm/claudathon
Paid annual subscribers who enroll get a refund for the current billing period.

4. Judgment Is the Feature

The benchmarks got their chart in Section 1. The interesting part of this launch is a behavior change.

One disclosure before the quotes: every voice quoted in praise here works at Anthropic. Read them as insider testimony, not independent validation, then check them against my receipts.

Karpathy called it “a major-version-bump-deserving step change forward,” strongest “for long problem-solving sessions on very difficult problems:”

The people building Claude Code describe the same thing. Cherny, from his launch post: Fable "has judgement, taste, and dimensionality in a way that previous models didn't:"

He asked it to debug something, and it took measurements, added logs, and verified the fix before declaring victory. Then the line that stuck with me: "There's nothing in claude code's prompting telling the model to do that, it's just part of its personality."

Thariq Shihipar compressed it to six words: "it's time to be more ambitious:"

The closest thing to an outside read, four days in, is the shape of the criticism. Researchers are angry about the invisible safeguards (Section 3). Dylan Patel of SemiAnalysis reports power users defecting to Codex after “refusals for nonsensical reasons.” Both complaints are about access to the capability. Neither questions the capability.

My version of that moment is the one this guide opened with. Fable read my instruction files and started surfacing contradictions instead of executing them. Previous models followed my rules. This one evaluated them.

Subscribe now

5. Your Knowledge Layer Was Built for a Weaker Model

Fable flagged the first contradiction on its own, mid-task, before I’d read anyone’s tips. So I gave it the full job: read everything my agents follow and report what’s wrong.

That conclusion is consistent with voices inside Anthropic. Alex Albert’s launch tips name the same mechanism: instructions written for old models keep Fable behaving like those old models. Rework your skills and CLAUDE.md files. Let the model use its own judgment first.

5.1 What Fable found in my repo

My agents maintain those files, not me. I trusted Opus to keep them clean enough. Still, five finds:

• A hardcoded date telling the model what day it is. One strategy file contains “(today is 2026-05-24)“, written during a May session and never noticed again. Every session since has been told the wrong date by its own instructions.

• A rule documented with the pattern it bans. My writing system bans em dashes in published content. The file that documents the ban is written with em dashes. Instructions teach by example as much as by rule.

• Calibration constants that drifted. An X voice rule still gates on an audience under 50K followers. That number was true when the rule was written. It isn’t two months later (75K).

• Guardrails for failure modes the new model doesn’t have. Rules like “never delegate judgment-heavy work to cheaper models“ and complex self-check procedures exist because earlier models needed them. Each one now eats context and pulls the model toward old habits.

• The same rule stated in three files. Three maintenance surfaces, three chances to drift apart.

Some were plain mistakes. The rest were right for the model they were written for. That’s exactly the problem. The better your system was for the last model, the more it holds back this one.

5.2 Written by a weaker model

The pushback I got within hours of posting my first thoughts on X: if your files contradict each other, isn’t that just sloppy housekeeping?

Fair question, wrong model of the system.

This knowledge layer isn’t a config file a human writes once. It’s self-improving: agents file evidence as they work, turn evidence into working rules, and edit their own CLAUDE.md (the system from Three CLAUDE.md Blocks). 166 files, maintained partly by the things that read them.

In a system like that, contradictions aren’t carelessness. They’re drift, the same drift every wiki and every org’s process docs accumulate, except here it accumulates as fast as the agents write.

That creates the real trap: a knowledge layer written by a weaker model has a flaw no amount of review can fix. Every line an agent added passed review by the model that added it, by definition. A system maintained by model N tends to preserve the errors model N can’t see.

I review these files every day and didn’t catch it. Neither did Codex, which reviews my knowledge files as a second pair of eyes.

5.3 The audit prompt

So the first prompt I ran with Fable 5 wasn’t a task. It’s the prompt I’d now run before giving any new model real work, and it’s yours:

Read your own instruction files (CLAUDE.md, skills, rules, memory files) end to end.

1. Where do they contradict each other? Quote both sides.
2. Which rules exist to manage a weaker model: guardrails for failure
   modes you don't have, recipes for things you no longer need spelled
   out, hardcoded facts that have drifted? List them with file:line.
3. Which rules teach by bad example: documents that violate the
   patterns they prescribe?
4. What would you delete? What would you keep exactly as is, and why?

Don't fix anything yet. Report first. I decide what gets cut.

The audit is the model's judgment; the deletions are yours. What you do with the report, and how I turned mine into a repeatable migration workflow, is where we go next.

Behind the paywall:

• The migration workflow → the three-bucket rule classification (constraint, calibration, scaffolding) so you cut anchors without cutting your actual taste

• Objectives, not tasks → the /goal patterns that let Fable run long PM work unattended + 2 prompt templates

• How deep agents and workflows stack now → my depth-10 experiments, the 2.54x cost multiplier

• Delegating and escalating work with Fable → my CLAUDE.md snippet

• What doesn’t work (yet) → the honest list, so you spend your first week on the parts that do

• The week-one plan → day by day, copy-paste ready

Read more

Here’s what you might have missed:

• Introduction to AI PM: Neural Networks, Transformers, and LLMs

• From Weeks to Hours: How Claude Design Compresses Product Discovery

• Claude Code for PMs: The Beginner’s Guide

• Claude Code’s Limits Are Generous. The Problem Is Your Setup.

• Three CLAUDE.md Blocks That Make Claude Get Smarter Every Session

Consider subscribing or upgrading for the full experience.

Subscribe now

Last week, inside Claude Code, I gave Claude a product-discovery job and added one short keyword: ultracode. I expected a better answer. Instead, it wrote a short program, spun up a fleet of agents, and ran the work through that program.

113 agents spent 1.95M tokens. The JavaScript that coordinated them spent zero model tokens. That distinction matters: the model did the judgment, the code did the coordination.

What surprised me wasn’t that Claude wrote code. It was that the most important coordination moved outside the model’s context window.

That changes how much one PM can run.

We’ll cover:

• What a dynamic workflow is, and the token number that proves it

• How it compares to n8n

• Why it works: four reasons, and the three failure modes a harness fixes

• The six patterns worth knowing

• A worked product-discovery loop on 100 interviews, end to end

• How to build, run, and contain one, and when not to

We won’t cover:

• The Agent SDK internals

• Fancy terms to memorize

This is the operating model, not the API docs.

1. What a Dynamic Workflow Is

1.1 The mechanism: the orchestrator is code, not a model turn

A dynamic workflow is a short JavaScript program Claude writes on the fly to coordinate subagents. You trigger it with the ultracode keyword, or by asking Claude to use a workflow. It reads the job, writes a script, spawns the agents, and merges what they return.

When you fan out 20 agents, something decides what each does, collects results, and drops duplicates. The old way, that something was the model, and every decision was a paid turn. Now it's ordinary code: loops, filters, sorting. None of it calls a model, so the routing is free. The agents still cost tokens; the glue between them doesn't.

1.2 How it compares to n8n

If you run n8n, you've made half this move. n8n took the glue between your tools and put it in a graph. A dynamic workflow takes the glue between agents and puts it in code. Same instinct, one level up.

This isn't an n8n replacement. n8n asks: how do I connect tools I already know? A dynamic workflow asks: how do I let the agent build the procedure for this run?

You could already ask Claude to write code that coordinates agents with the Agent SDK, but those are embedded agents: the ones you build into your own app or product. A dynamic workflow coordinates workspace agents: the ones doing your actual work (coding, research, knowledge work) inside Claude Code. The SDK is for the agents you ship; dynamic workflows are for the agent you work with.

1.3 When a workflow beats a subagent

How do you know it’s time to stop prompting and start orchestrating?

Subagents already fan out and synthesize: Opus delegating to a fleet, one round, then a merge. So a single fan-out is not the reason to reach for a workflow. The reason is what happens after the fan-out, when the output of one stage decides the next.

A mental model:

• Use subagents when the job is one round of parallel judgment.

• Use a dynamic workflow when stage N’s output determines stage N+1: route, score, filter, loop, retry, generate, verify, build.

For PMs: subagents are the workers; the workflow is the operating procedure. The expensive resource (a model's reasoning) goes to each stage; the cheap resource (code) decides the order, which model tier runs each stage, and what carries forward.

2. Why Move the Orchestrator Off the Model

The reason to reach for a workflow isn't that it's more "advanced" than an agent. It's that it moves the fragile part out of the model's context. Order, routing, stopping, and model choice become code. The model still does the thinking; it no longer has to remember the plan, police its own laziness, grade its own work, or decide when the job is done.

The structure that does this got a name that caught on in 2026: a harness. I'd been making the same case since 2025, under a different one: orchestration over autonomy. The model gets the judgment; the structure around it gets everything else.

Four things follow:

• Determinism. Code owns the order, the routing, and the stop condition. They run the same way every time, instead of depending on whether the model feels done.

• Context isolation. Each agent gets a fresh, bounded job. The goal lives in the script, not in a window that compacts and drifts.

• No orchestration-token tax. The coordination layer isn’t another model conversation, so routing the fleet is free (§1.1).

• Model tiering. Bounded, repetitive stages run on a cheaper model. (Subagents can do this too; it’s a pro tip, not the differentiator.)

The first two are the point; the last two are why it’s cheap. You feel their absence as three specific failures, and I’ve hit all three.

2.1 Agentic laziness

Ask Claude to review all 50 items; it reviews 35, writes a confident summary, and declares it done. A workflow holds the 50 in a for loop and runs until the array is empty. Humans get tired and models drift; a loop just checks the same condition again.

2.2 Self-preferential bias

Ask Claude to grade its own work and it grades generously, especially in judge-or-verify tasks. A workflow makes the judge a separate agent, with separate context, sometimes a different model. Spawn several skeptics, require a majority. The bias doesn’t survive being split.

2.3 Goal drift

Over a long session the objective loses resolution; every compaction is lossy, and the “don’t touch auth” constraint can evaporate by turn 80. A workflow holds the goal in the script, outside the model’s drifting memory. Agents come and go with fresh context; the goal doesn’t drift because it was never in a context that compacts.

For PMs: you've seen all three: 70% delivered as 100%, a self-review an outsider would shred, a Friday build that forgot Monday's requirement. Name the step your agent keeps redoing. That's your first workflow.

3. The Six Patterns Worth Knowing

Once the orchestrator is code, six shapes recur. Learn the names; they're how you recognize what a task wants.

• Classify-and-act: one agent decides the task type; the script routes accordingly. Reach for it when: triaging inbound (bug vs feature vs noise), routing support tickets.

• Fan-out-and-synthesize: one agent per piece in parallel, then merge in code. Reach for it when: competitor teardown, customer-call synthesis, a market map.

• Adversarial verification: separate agents check the output against a rubric. Reach for it when: fact-checking a PRD against its sources, a second reviewer on a risky call.

• Generate-and-filter: many candidates, filtered and deduped, survivors kept. Reach for it when: naming, positioning lines, experiment ideas.

• Tournament: N agents attempt the task different ways; judges compare until one wins. Reach for it when: a strategy memo or a hard design with no single right approach.

• Loop-until-done: keep spawning until a stop condition (no findings, no errors, empty queue). Reach for it when: a backlog triage or an audit where you don’t know how much work there is.

For PMs, on your actual work:

• Synthesize customer interviews → one agent per transcript, merged into a themes-and-JTBD table. Every interview read, not the first 20 (the worked example below runs this on 100).

• Check 80 user stories against INVEST → a loop that runs until every story is checked, not until the model tires at 50.

• Pressure-test a PRD before the review → a separate agent red-teams it against your goal and surfaces the assumption you’d otherwise defend at launch.

You're not learning to code. You're learning which weekly PM jobs can become standing workflows: set the goal once, save the procedure as a skill, and let it run end to end.

Subscribe now

4. A Worked Example: A Product Discovery Loop on 100 Interviews

This is where a workflow earns its keep.

Here’s the pipeline I ran on 100 synthetic customer interviews (1-2 pages each).

Six stages, each feeding the next:

• Step 1: Extract → fan out one cheap-model agent per interview; each returns structured opportunities, personas, and verbatims. Bounded, repetitive work: Haiku or Sonnet, not Opus.

• Step 2: Canonicalize → one agent clusters the raw opportunities into a canonical set. The extractors invent a fresh label per interview, so the same need arrives under a dozen names; merging synonyms is judgment, so it’s a model, not code.

• Step 3: Opportunity score → code ranks each canonical opportunity by frequency × importance × (5 - satisfaction). No model runs the math.

• Step 4: Generate and triage → for the top-scoring opportunities, an agent generates several solution ideas; a separate judge then ranks each by ROI (impact vs build effort) and keeps the top 3 to build. ROI re-orders the list, so a cheap, high-impact need can take a build slot from one that scored higher.

• Step 5: Build → for the top 3 ideas by ROI, an agent uses the frontend-design skill to write a distinctive, clickable HTML prototype I can open.

• Step 6: Inspect and rerun → a smoke check flags any prototype that fails to render, or any extraction that came back low-confidence, and the workflow reruns just that stage. This is the real loop: the output of one stage decides whether an earlier stage runs again.

That second stage wasn't in my first prompt. I'd written "merge and dedupe" and assumed code could do it; the counts came back fragmented. So I added one line to the prompt, cluster synonyms to a canonical set before counting, and Claude rewrote the harness with a clustering agent in front of the scorer. Even the fix lived off the model.

This is how it runs:

I measured the run: 113 agents spent 1.95M tokens in 12.5 min. 3/3 prototypes built and verified. The JavaScript that routed, scored, gated, and looped spent zero model tokens.

That's the payoff. The rest is how you build it 👇

Read more

More than 800 tests and eval checks across the three repos, from unit tests to LLM judges, nearly all green. I’m a PM, not an engineer, and I barely read the code.

And this isn’t just me, or just indie builders shipping side projects. A Google PM described the shift from writing-first to building-first:

It’s not only Google.

Meta PMs now vibe-code prototypes and demo them straight to Zuckerberg, and the company added a prototyping round to its PM interview; LinkedIn replaced its APM program with an “Associate Product Builder” role gated on a live AI build. The prototype is becoming the PM’s first deliverable inside large companies, not a side-project trick.

So what did I review? The artifacts:

• the plan before it ran

• the decisions it encoded

• the strategy the agent reads every turn

• the docs that say what the thing does and why

It’s the same shift whether your surface is a repo, Claude Code, Cowork, or a chat window. Experimenting got cheaper than building agreement, and that reorders the work.

None of them started with a spec. Each started with a conversation, and what I kept was the artifacts.

What this post covers:

• What the artifact layer is, and why a PM reviews it instead of the code

• Why building now comes before agreement, not after

• Where your strategy has to live to actually steer the agent

• The boundaries that let you hand an agent real autonomy and walk away

• The AI Shipping Artifact Prompt Pack to download at the end

Subscribe now

What I Actually Ship Now

The product is the obvious artifact: the extension on the Marketplace, the tool people install. The one that decides whether the next change goes well is less obvious. It’s the knowledge layer.

Not the README or the changelog, every repo has those. The docs that hold the decisions: why this architecture, who it’s for, what we ruled out:

• In PM Brain that’s files like architecture.md and why-this-matters.md

• For accredia.io it was more than twenty docs, from database.md and security.md to a fuckups.md

• For a multi-agent app I built with my cohort, it was the agent contracts: what each agent takes in, what it returns, which tools it can touch, and how they hand off.

Keeping that layer true is a question of what to automate, and when:

• In claude-usage, git tags are generated from the CHANGELOG automatically: the changelog is the source of truth, the tag is a deterministic projection.

• In Grok I keep version bumps manual on purpose, because automating them there hasn’t earned its keep yet.

Seven things shipping this way taught me.

Lesson 1: Review Artifacts, Not Code

The question I get from PMs is “do I have to learn to code?” I don’t, and I don’t review the code, beyond the odd snippet.

That layer isn’t a side effect of the build. It’s a deliberate, human-and-agent-readable summary of the solution, so neither of us has to reverse-engineer the product from the source. It often duplicates what the code already says, and that’s the point: it’s far easier to consume.

It’s also what I check the code against. When I care whether the implementation matches the intent, whether the security model holds, whether performance is where it should be, I read the artifact, not the diff.

So when work comes back, I don’t read changes in the code. I read changes in the artifacts. I review across three modes, escalating only as far as the decision needs:

Cheapest mode first. A durable artifact is the receipt: it survives the context window, and it survives me. Only commit one when the alternative is losing the thread.

Here’s one from a build. I opened the session with a document, not a ticket: “See the research in plan-mode.md. Can we really implement that logic reliably on our side?”

The agent didn’t start writing code. It read the doc, ran a quick probe to test the doc’s core assumption against the real tool, and reported what it found. I signed off on the approach from that exchange, not from a single line of the implementation.

And this matters more on a team, not less: your teammates don’t carry your context in their heads, so the artifact layer is how a decision or a hard-won finding survives past the person who made it.

Subscribe now

Lesson 2: Build Before Building Agreement

The old motion was: write the PRD, get everyone to agree, then build. That order made sense when building was the expensive part. You spent weeks of engineering, so you spent days up front making sure it was the right thing.

That’s why I shipped two major releases in a day, and why none of these projects started with a spec. Two-week iterations start to feel dead in this mode. Not because planning is useless, but because the unit of learning changed: when a working version costs an afternoon, a sprint is too slow to be the main loop. You ship, watch, revise, and ship again before the old process would have turned the debate into tickets.

A prototype, even a rough one, collapses the ambiguity: the team sees what the customer clicks, where they hesitate, what they ignore, what they ask for next. Highly regulated industries aside, agreement around an untested doc is low-value at best: the idea changes the moment it touches reality. At worst it's harmful, because the team gets attached to a product that only existed in language.

Lesson 3: Put Strategy Where the Agent Works

I still write the strategy down:

• who it’s for

• what changes for them

• what I won’t build

• the trade-offs I’ll accept

• what would make the work a failure

What changed is where it lives and what it’s for. It doesn’t sit in a folder someone might open before a kickoff. It lives in the repo, a strategy.md the agent reads every time it acts.

If the strategy isn’t in its context, those decisions get made from whatever’s nearby: the last prompt, the surrounding code, a guessed convention, the model’s own confidence.

The repo becomes the product’s memory, too:

• experiments

• decisions

• evals

• screenshots

• release notes

• the constraints I hit

They accumulate there anyway. My job is to keep that context clear enough that the agent can use it. (The one thing I stopped writing is the spec, the user stories and acceptance criteria that told engineering exactly what to build. That part is cheap now; it falls out of the conversation.)

Your strategy is only doing work if it changes what the agent does next.

Share

Lesson 4: Cross-Examine Confident Answers

I asked Claude to bump the version and publish. It was confident: “Just run the publish command. CLAUDE.md says the publisher’s already authenticated.” I almost did it. Then I asked: “Are you sure? I’ve been publishing by hand through the Marketplace website.”

The confidence collapsed. That claim was from a past session I’d never verified, and the setup it promised had never happened. The command would have failed at the first step.

That one was harmless. A command fails in front of you, you fix it in a minute. The claims that bite are the confident ones you act on instead of run, where the failure is silent and lands downstream. Pushback is how you catch those before they cost you. The moment you ask “are you sure?” carries more weight than the next instruction you give.

But you can’t interrogate everything, or you become the bottleneck you were trying to remove. So I triage. I cross-examine the confident answers that are expensive to be wrong about:

• irreversible changes

• anything touching auth, billing, security, or the data model

• anything that becomes context future work depends on

• any claim that sounds too clean

The strongest version of pushback isn’t you, though. Your attention doesn’t scale. A second model gives you more review surface without funneling every hard question back through your head.

When I had the extension audited for bugs, the agent built a confident, elaborate theory and walked straight past a one-line bug in the same function: a failure was being reported as a success. Trust that, and it keeps building on a false "it worked": wrong analysis, maybe a destructive next step. Codex caught the one-liner Claude had talked itself past.

A second copy of the same model shares its blind spots. A different model, trained differently, fails differently. Self-review feels like diligence. Cross-review is. (I wrote up how I wire Codex alongside Claude separately. You can watch one play out in public: the cross-check narrowed a contributor’s over-broad fix to a single bad value, and he confirmed it.)

Lesson 5: Make Failures Teach the System

The best artifacts in my projects usually began as failures I didn’t want to debug twice.

The loop is the same every time: a failure surfaces, I find the smallest thing that would have caught it, a test, an eval, or a line of policy, and I make it permanent so the system can’t forget it.

The most load-bearing line in my CLAUDE.md is four words: “Don’t introduce abstractions speculatively.” It earned its place after an earlier project drowned in structure it didn’t need. A line copied off social media is a guess about a problem you might have; a line written after the third time something went wrong is policy. accredia.io keeps a fuckups.md in its docs; that’s where its rules come from.

Tests are the same idea in a different file. Early on, the model offered a 27-test suite and I took it, but the next bug I hit wasn’t in any of the 27, it was a sequencing problem they tested around. So now, when a real bug shows up, I ask: “What’s the smallest test that would have caught this?” and add that one.

The claude-usage triage routine mechanizes it: on every fix it adds the test, then reverts the fix to confirm the test fails without it. A green suite proves the past; manual smoke probes the future.

Evals are the same instinct for AI that’s in the product: read the traces, name what’s failing, then turn each failure into a test, an LLM judge, or a new line in CLAUDE.md. PM Brain’s judges are each named after a real failure (decision_quality, evidence_hierarchy_respected), never from a spec up front. (I go deeper in evaluating AI products through error analysis.)

Subscribe now

Lesson 6: Point Every Agent at One Source of Truth

I had three coding agents open during this build: Claude Code in the terminal, a Grok tab in VS Code, and Codex through a separate skill. Same repo, same files, three independent conversations. Without a shared source of truth, they’d have proposed three different architectures, and I’d have spent the build arbitrating instead of building.

So I keep one master doc: CLAUDE.md, with the project, the conventions, and the decisions already made. The other agents don’t read it by default, so each gets a tiny AGENTS.md whose only job is to point them at it. It duplicates nothing; it just redirects.

In claude-usage I flipped the direction: there AGENTS.md holds the guidance and CLAUDE.md is one line, @AGENTS.md, that imports it. Either way works. One source, everything points at it.

It isn’t only CLAUDE.md, either. The source of truth is the whole working-context layer, the docs, rules, skills, and hooks each agent can reach, and I keep that synced too. Each agent can have its own entrypoint; it shouldn’t have its own reality. (Full setup in Codex Setup for PMs.)

Lesson 7: Grant Autonomy, Enforce Boundaries

Early on, I babysat every run. I watched the model think, approved each step, sat at the screen the whole time. That doesn’t scale across the number of things I’m trying to ship.

The shift was setting a goal, giving the agent room to pursue it, and walking away. The clearest example runs every week without me. The goal: go through every open pull request and feature request on claude-usage, merge the clear bug-fixes, mark the duplicates, push out-of-scope features to a Discussion, and report back only what couldn’t be resolved. It runs headless, on a schedule. I read the summary later, often from my phone.

Autonomy that wide only works with two kinds of limit, and the difference is the whole game:

Steering prompts are soft: a one-line reminder, or a repeatable procedure like the gate rules in my content system. Either way, under pressure the model can talk itself out of one.

Hard boundaries are enforced where the model gets no vote. In the triage routine:

• nothing closes unless the second model writes a sign-off file with an exact approval phrase

• it won’t auto-merge anything touching auth, secrets, or more than 200 lines

• it never pushes to main

Those aren’t requests. They’re mechanical gates.

The strongest version of a hard boundary is the tool surface itself. In the Grok extension, plan mode isn’t a polite “please don’t edit files yet.” The extension gates the actual file-write and terminal calls, so while a plan is pending the model physically cannot touch the disk.

Same idea as a Claude Code hook or a tool allowlist: if a limit has to hold, it lives in code, not in a sentence the model can reinterpret. PM Brain enforces a different limit the same way: a hook fires after every file write and blocks the agent from saving a brain file with an untagged claim. No clean save, no write.

The same logic runs at the shipping boundary. On claude-usage, no pull request merges to main on a red test suite. I didn’t know how to wire that up, so I asked Claude to set the branch protection for me. The agent can be confident and a contributor can be in a hurry; the merge button stays disabled until the tests pass.

PM Brain’s /review edits knowledge files on its own, but it’s hard-stopped from changing a decision’s status; that judgment is mine. Wide lane, real walls.

What Still Needs Human Judgment

Here’s what the system still can’t decide for me.

• Models over-rate their own findings. In that audit, the agent tagged three findings “high severity.” Checked against the actual code, all three were medium or low. The model is good at producing candidates. Deciding what’s actually serious is still mine.

• A second model helps; it isn’t magic. Two models from the same family share blind spots. Claude and GPT diverge enough to be worth pairing, but neither makes the load-bearing check stop being yours.

• Taste regressions still need eyes. No agent caught the copy button overlapping the header buttons. I did, on a manual pass. Design judgment isn’t in the test suite.

• The workaround becomes part of what you ship. Grok’s CLI returned unreliable tool results, so every session in the extension opens with a hidden primer: “Do not trust the tool result.” That scar tissue is product judgment too.

So What Do PMs Ship Now?

Across all of it, the extension, the knowledge system, the premium section behind this newsletter, the pattern held.

None of it shipped because I wrote a better spec, and none of it shipped because I read the code. It shipped because the conversation was good, and because I kept the few artifacts that turned out to be load-bearing: the strategy, the decisions, the constraints, the CLAUDE.md the agent actually reads.

PM Brain made it obvious. The brain it scaffolds is 44 markdown files around a single CLAUDE.md, and that structure emerged from use, not from a document I wrote first.

The AI Shipping Artifact Checklist

If the artifact layer is what you actually ship, here’s the starting set. Organized by purpose, not by stack, because the project changes but the knowledge-layer needs don’t. Steal the list; name the files whatever fits your repo.

None of these is a spec. Each is a place the decisions live, so you and the agents can read them instead of reverse-engineering the code. You don't have to hand-write them, either.

The AI Shipping Artifact Prompt Pack

One download, two kinds of thing, both built around the artifact layer above:

• The artifact prompts: seventeen of them, one per kind of file and risk, from strategy to workflow maps to cross-model review. Point an agent at your repo, run a prompt, review the doc it writes. They generate the layer; they aren’t the layer.

• The audit commands: a static security audit and a performance twin, for code you didn’t write. The security one, /security-audit-static, traces untrusted input to the places it could do real damage, then refutes its own findings before reporting. I pointed it at Langfuse, a leading LLM engineering platform, and it surfaced a real weakness in how provider connections were fetched. The hardening fix merged, 964 lines added, 334 removed.

Some of the 20+ issues I’ve since responsibly disclosed to public-repo security teams (Langfuse at the top):

Get the pack below: 👇

Read more

Codex grew from about 200K to roughly 4M weekly active users in four months. Claude Code crossed 2M in early March. If you opened this post, you're probably one of those 2M. The other 4M are on a tool you haven't tried.

And it's not just a developer tool anymore. If VS Code has felt like a wall, the Codex app is a chat window with a file tree, visual diffs, and long-running sessions. PMs who've avoided code repos no longer have to.

ChatGPT Plus is $20/month and includes Codex. The setup takes about five minutes. This guide is the walkthrough.

By the end of this guide, you’ll have:

• Codex app installed and pointed at your repo

• AGENTS.md bridged to CLAUDE.md so both runtimes share one source of truth

• Plugins installed for the apps you use, with project skills mirrored if you build with AI

• MCPs running in both runtimes, with a one-shot prompt to do the import

• Claude Code able to call Codex as a peer for review

• A plan for working from your phone (cloud tasks vs. remote control)

Full Cowork / Claude Code / Codex comparison is at the bottom. First, the setup.

Subscribe now

1. Why Add Codex as a PM

Five reasons I added Codex, in order of how often they show up in my work:

• A way into a repo without VS Code. If the IDE has felt like a wall, the Codex app (desktop) is a chat window with a file tree, visual diffs, and long-running chat sessions. No commands to learn, no extensions to wire. You can even edit files by leaving comments for Codex. Cowork is chat-first; no tree, no diffs.

• Manual Compact. You decide when to compress the session instead of waiting for the model to hit the wall. In Codex, type c, then /com, and choose Compact when it appears. Claude Code has /compact in the CLI. Cowork does not have an equivalent manual reset. This matters for your budget: Claude Code’s Limits Are Generous. The Problem Is Your Setup.

• An extra perspective. When I want a second pair of eyes on a prompt, or a piece of code, I hand it to the runtime that didn’t write it. Different model, different misses.

• Image generation in the bundle. The ChatGPT subscription that Codex ships with includes image generation. Claude doesn’t cover that workflow.

• Runs next to Claude Code on the same repo. Same files, same skills, same MCPs. Switch runtimes without rebuilding your setup.

Subscribe now

2. Install Codex (Desktop App and VS Code Extension)

You'll install two things. Codex app (desktop) is the chat workspace where long sessions and Compact live. Codex for VS Code is the editor extension that lets you call Codex in the same window as Claude Code.

Both share one OpenAI login, both work on the same repo, and you'll use both for different jobs.

Codex app (desktop)

Download Codex app from OpenAI. Sign in with the ChatGPT account that has Plus, Pro, or Business. Codex is bundled with all three.

The first prompt asks you to migrate your VS Code settings. I skip it. Not because it’s hard. Because you should know what’s being imported before you click yes. You can always migrate later from Settings or by asking Codex for help.

Open the same project folder you already use with Claude. The file tree loads on the right. Visual diffs appear in the same panel.

Codex for VS Code

Install the Codex extension from the VS Code marketplace and sign in with the same OpenAI account.

If you already use the Claude Code extension in VS Code, both extensions will show up in the activity bar. You can switch between them by tab.

Why both surfaces? The Codex app is for long chat sessions and Compact. Codex for VS Code is for editing the repo, including dot folders (.agents, .codex) that the app’s file picker hides - full dev experience.

Subscribe now

3. Teach Codex Your Repo: AGENTS.md to CLAUDE.md

Codex looks for AGENTS.md at the repo root. Claude Code looks for CLAUDE.md. If you maintain both as separate sources of truth, they drift.

The fix is a one-file bridge. AGENTS.md is a short pointer. CLAUDE.md stays the canonical document. Codex reads AGENTS.md, sees the pointer, follows it.

Drop this at the repo root as AGENTS.md:

# AGENTS.md

This repository keeps its canonical agent instructions in [CLAUDE.md](./CLAUDE.md).

When operating in this repo:

1. Read and follow `CLAUDE.md` as the source of truth.
2. Treat references to "Claude Code" as applying to Codex when you are the acting agent.
3. Do not duplicate `CLAUDE.md` content here. Update `CLAUDE.md` instead.

One file. One source of truth. Both runtimes follow it.

AGENTS.md is the bridge. CLAUDE.md is the long part. The structure I use:

1. Communication: How the agent should talk, what content it should produce.

2. [For personal work] About me: Role, audience, social media handles

3. [For product work] Strategy: Market segments, value propositions, tradeoffs.

4. Project structure: Where things live, architecture, conventions.

5. Workflow: How we do things (reviewing, shipping). Not a procedure manual. The rules of engagement.

6. Progressive disclosure: Links to deeper files (strategy.md, knowledge/INDEX.md, whatever you’ve built) that load on-demand, not on every session.

Each section earns its place when something would otherwise have to be re-explained per session. CLAUDE.md isn’t documentation. It’s the agent’s memory of how you work.

Progressive disclosure matters because context isn’t free. Don’t dump 500 lines of text into CLAUDE.md if 100 of it only matters for one workflow. Keep the core file lean. Link out to the rest.

4. Configure and Share Skills

If you haven’t used skills before, think of them as reusable instruction bundles. A SKILL.md file tells the runtime when to fire and what to do.

Two ways to configure them in Codex.

Start with user skills. The Codex app ships with a Plugins panel. One click installs Gmail, Linear, Jira, Slack, and others. You get the app’s connection and its skills together.

With Plugins installed, Codex reads your CLAUDE.md and talks to the apps you use daily.

That’s the minimum viable Codex setup for a PM.

The next step is making Codex and Claude Code behave like one operating system: curated skills, project skills synced between runtimes, mirrored MCPs, and a repeatable review loop.

Read more

When looking for a job, expect:

• “How do you use AI/Claude in your day-to-day?”

• Vibe coding / prototype rounds: from PRD to evals

• Portfolio/case studies: Show agents/prototypes built with AI

• Questions focused on AI product sense + execution with agents

Even people like Garry Tan (Y Combinator) went back to "coding" and ships a custom brain for agents after work hours:

In the past, we’ve discussed many aspects:

• The Guide to Claude Code for PMs

• What I Learned Building a Self-Improving Agentic System with Claude

• Three CLAUDE.md Blocks That Make Claude Get Smarter Every Session

• Your .claude/ Folder Is a Production Agent

• The Ultimate Guide to Claude Opus 4.7

• Claude Code's Limits Are Generous. The Problem Is Your Setup.

The first Guide above assumes you’ve used Cowork. Talking to the community, I realized many PMs haven’t, and they need a zero-to-one path.

This article has everything you need to start:

1. How to install Claude Code step-by-step

2. A ready-to-use Claude Code solution template

3. How to configure MCP servers in Claude Code step-by-step

4. How to use and create skills in Claude Code step-by-step

5. How to use Claude Code with free frontier models

Subscribe now

1. How to Install Claude Code Step-By-Step

This combines Claude Code with the recommended interface, Claude Code extension in VS Code.

Step 1: Install Visual Studio Code for MacOS or Windows

Step 2: Launch VS Code, click “Extensions,” and install “Claude Code for VS Code”

Step 3: Log in with Claude.ai Subscription after typing “/login” in the Claude window. There are two interfaces, it’s easy to get confused:

• Skip this one: Claude Code in Terminal - opens at the center

• Use by default: Claude Code Extension for VS Code - opens in the secondary side bar on the right

Note: On the right side in the video you can see two tabs:

• [Codex] - OpenAI extension I installed earlier

• [Claude Code] - that’s our Claude Code extension

Sometimes you may also see “Chat” - it’s a Microsoft solution. Ignore it.

2. A Ready-To-Use Claude Code Solution Template

This knowledge work template contains everything you need to start:

• Preconfigured plugins, skills, and permissions

• My minimal CLAUDE.md that makes your agent more autonomous

• Setup that reduces costs by at least 50% by managing models, subagents, and context windows better

• Ready-to-use configuration so you can work with free frontier LLM models

You can download the solution below (click File > Download):

claude-template.zip

Extract the archive and open it with VS Code:

You will see:

Inside:

• Predefined configuration:

  • CLAUDE.md / AGENTS.md - agent’s constitution

  • settings.json - cross-team project settings, predefined permissions and plugins

  • settings.local.json - your local project settings with 200K context window and 80% autocompact

• Examples:

  • SKILL.md - an example custom skill, you can remove it.

  • tools/reddit_api_example.py - an example custom tool generated by Claude. You can remove it, in that case remove line 53 from AGENTS.md too.

  • .env - here, you configure your API keys. Not committed to GitHub. You can remove two lines: REDDIT_CLIENT_ID and REDDIT_CLIENT_SECRET.

  • .mcp.json - an example custom MCP server. You can remove Linear (lines 3-6), if you don’t need it.

Tasks for you:

• Review and remove or adapt examples listed above.

• Update ## Strategic context, about me in AGENTS.md with a brief summary of your strategy or/and about you (for an individual)

• Update ## Communication and style in AGENTS.md so it follows your writing style and preferences

• Update docs/strategy.md with a information about your product

3. How to Configure MCP Servers in Claude Code Step-By-Step

MCP is a common protocol to connect apps such as Stripe, Gmail, Notion, Jira, or Slack. The easiest way is to go to https://claude.ai/customize/connectors and configure them there:

Those connectors are automatically available in Claude Code, too, as long you use a Claude subscription. Here’s how Claude works with my Gmail Connector:

Task for you: Connect the apps you use the most, such as Gmail, Notion, or Google Calendar. Configure actions that require your approval, such as sending an email, in claude.ai (presented in the screenshot above).

For apps not available in the Claude catalogue or when using a free LLM, use Google to find a dedicated MCP server and ask Claude to configure it in a chat based on the documentation:

MCP servers can be available:

• Only for you when using this project

• For any user using this project

• For any project on your local machine

Include your preference in the prompt.

4. How to Work with Skills in Claude Code Step-By-Step

Each skill gives Claude domain knowledge, analytical frameworks, or a guided workflow for a specific task.

They always contain SKILL.md file and can also include additional resources, for example:

---
name: substack-to-pdf
description: Export Substack posts to self-contained PDFs
  with embedded images.
---

# When to use
When asked to create PDFs from Substack posts.

# Steps
1. Fetch post HTML
2. Download images, embed as base64
3. Render with Playwright

# Files
- script.py
- styles.css

By default Claude can see only the frontmatter ("description"). The full skill is loaded automatically when relevant to the conversation.

4.1 Skills and plugins available publicly

Top recommended public repos. Each contains installation instructions. You can also give your agent an URL and ask to import specific skills:

1. github.com/phuryn/pm-skills: PM Skills Marketplace — 100+ agentic skills, commands, and plugins — from discovery to strategy, execution, launch, and growth

2. claudemarketplaces.com: Browse and discover plugin marketplaces you can add to Cowork or Code

3. github.com/travisvn/awesome-claude-skills: Community-curated collection with battle-tested skills for TDD, debugging, collaboration

4. github.com/sickn33/antigravity-awesome-skills: 868+ universal agentic skills — covers security, DevOps, full-stack, AI/ML, and more. Role-based bundles (Startup Founder, Marketing & Growth, etc.) let you pick what’s relevant. Works with Claude Desktop, Claude Code, Cursor, Gemini CLI, Codex, OpenCode, and Antigravity

5. skills.sh: Vercel’s open skills ecosystem — directory and leaderboard, CLI installer (npx skills add). PM-relevant skills include product strategy frameworks, pricing strategy, launch playbooks, discovery interview guides, PRD generator, analytics tracking setup, resume optimizer, and more. Full repo also covers marketing, SEO, copywriting, and web design.

The bottom line: don't install skills you don't need. Start with none and add one when a real task forces it. Even unloaded skills cost context - the frontmatter description always loads.

4.2 How to create your own Claude Code skills

When you perform a specific task multiple times, ask Claude to turn it into a skill. It's way easier than editing markdown files manually.

Here, I continue the example from point 3:

Next time you ask Claude to summarize emails, it will reuse that logic while saving tokens.

Tip: Skills can be available for any user using this project or for any project on your local machine. It can also be called as subagent - use this option when the skill doesn't need your entire conversation history. Include your preferences in the prompt.

Task for you: When you notice a recurring pattern, ask Claude to turn it into a skill.

5. How to Use Claude Code with Free Frontier Models

Before you start: There is an open Anthropic bug, 36179. Using alternative models works only with Claude Code in terminal, not with the Claude Code extension for VS Code. Start by using your Claude subscription, especially if you're not comfortable with Claude Code yet.

Step 1: Go to OpenRouter, sign up: https://openrouter.ai/

Step 2: Verify your email address by clicking a link in an email message

Step 3: Add $5 credits to your account (to verify the account): https://openrouter.ai/settings/credits

Step 4: Create a free API key: https://openrouter.ai/workspaces/default/keys

Step 5: Open a folder with your project. Create settings.local.json in the .claude folder. Inside:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://openrouter.ai/api",
    "ANTHROPIC_AUTH_TOKEN": "{your-API-key}",
    "ANTHROPIC_API_KEY": ""
  },
  "model": "inclusionai/ring-2.6-1t:free"
}

You can also rename this file, already in your template. Create a backup of the original settings.local.json:

I suggested inclusionai/ring-2.6-1t:free. It’s a 63B model with a 262K context window. Note: free models on OpenRouter change regularly.

Here’s how it works with Claude Code in terminal, completely free:

Task for you: Get comfortable with Claude Code and Anthropic models before switching to alternative models. You don’t want to learn Claude Code and solve OpenRouter issues simultaneously.

Closing

You have everything you need to start.

Install it this week. Connect apps (MCP servers) you’ll actually use. Build one skill from a task you already do twice.

The more you use Claude Code, the easier it becomes. Later, review other posts listed in the intro:

• The Guide to Claude Code for PMs

• What I Learned Building a Self-Improving Agentic System with Claude

• Three CLAUDE.md Blocks That Make Claude Get Smarter Every Session

• Your .claude/ Folder Is a Production Agent

• The Ultimate Guide to Claude Opus 4.7

• Claude Code’s Limits Are Generous. The Problem Is Your Setup.

Thanks for Reading The Product Compass

It’s amazing to learn and grow together.

Have an amazing rest of the week, Paweł

The same workflow cost me €1,184.95 (~$1,389) a month ago:

No model swap, no skipped sessions.

Between March 23 and April 23, some users on Max burned weekly quotas in 1-2 days. Anthropic shipped 3 bug fixes (v2.1.116+) and reset all subscriber limits. Full writeup in their April 23 postmortem.

Four root causes are still on your side (I’ve been researching and testing that for the last 2 weeks):

1. Cache misses

2. Context bloat

3. Wrong model or effort

4. Wrong input format

Our Sponsor: Nimbalyst

This is a paid placement, but I only run sponsors I've actually tested. I’ve been working with Nimbalyst for 10+ hours.

It’s a visual workspace for Claude Code and Codex. If the VS Code interface has intimidated you, you should try it.

I loved the markdown files that actually render without plugins, and navigating between linked documents. VS Code is missing this.

Big surprise: sessions as cards on a Kanban board. Backlog, planning, implementing, done. Claude doesn’t have this.

Plus session tracking, all the context window techniques we’ve been discussing, and a native iOS app (their custom remote control). Works with your Claude Pro/Max/Team subscription, not just API keys.

Free for individual use. Worth twenty minutes if you’ve been Claude-Code-curious:

Download Free

1. Cache Misses

The prompt cache is the single biggest lever in Claude Code. Most people never look at it.

The math:

• Cache read: 0.1× the input price

• Cache write (5-min TTL): 1.25×

• Cache write (1-hour TTL): 2×

• Cache refresh on hit: free (charged at the read price)

Every hit on a cached prefix resets its TTL at no extra cost. So a long session with steady tool use stays warm indefinitely as long as the prefix doesn’t change.

Thariq spelled out the rules in “Lessons from Building Claude Code.” The two that move the needle:

• Lock your tools at session start. Adding or removing a tool mid-session invalidates the cached prefix and forces a full re-read. Never add or remove tools mid-session.

• Lock your model at session start. Switching models mid-session blows the cache for the same reason.

~90% is healthy on the 5-min default. On the 1-hour TTL it climbs to ~97-99%, but that one is API-only and isn’t priced into Pro / Max / Team subscriptions.

What to Do:

• Protect the prefix. Don’t add MCP servers mid-session, don’t /model mid-session.

• Watch the hit rate. See § Watch the Number below.

• Consider the 1h cache for long sessions on the API. Write costs more (2× vs 1.25×), but the higher hit rate pays it back.

2. Context Bloat

For Opus 4.7, 1M context is the default. That’s expensive. Long sessions sprawl, and auto-compact fires later than it should. Disable it and fall back to 200K. 200K is enough for almost any task.

On 200K, auto-compact fires at ~155K (~80%), the behavior Boris Cherny described for the previous Opus. The trick is to compact before you hit the auto-trigger. Once it fires, it pushes you over and warms a fresh prefix. Compact early instead.

The settings I run:

{
  "env": {
    "CLAUDE_CODE_DISABLE_1M_CONTEXT": "1",
    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "80"
  }
}

That disables 1M context and pins the auto-compact threshold at 80%.

2.1 Five Session Moves

• /compact at 50% or after every task. Don’t wait for auto.

• /clear between unrelated work. New session = fresh prefix.

• /rewind when a turn went sideways. Cheaper than re-prompting around the bad context.

• Subagents for anything that doesn’t need the parent’s reasoning.

2.2 Subagents Are the Underused Move

Anything that’s bulk-mechanical, scoped research, or parallelizable should run in a subagent. The parent context stays clean and you parallelize across cheaper models.

A CLAUDE.md task-delegation block I keep in every project:

## Subagents v1.0

Spawn subagents to isolate context, parallelize independent work, or offload bulk mechanical tasks. Don't spawn when the parent needs the reasoning, when synthesis requires holding things together, or when spawn overhead dominates.

Pick the cheapest model that can do the subtask well:
- Haiku: bulk mechanical work, no judgment
- Sonnet: scoped research, code exploration, in-scope synthesis
- Opus: subtasks needing real planning or tradeoffs

If a subagent realizes it needs a higher tier than itself, return to the parent.

Parent owns final output and cross-spawn synthesis. User instructions override.

2.3 Skills Can Also Be Invoked as Agents

Add agent: true and model: to the frontmatter and the skill runs in its own subagent context with its own model. For example:

---
name: tldr-pdf
description: Extract a 200-word TL;DR from a PDF without loading the full text into the parent context
agent: true
model: sonnet
---

You receive a path to a PDF.

1. Run `pdftotext "$1" -` to extract the text.
2. Read the output.
3. Return only:
   - 5-bullet TL;DR
   - 3 quotes worth keeping
   - Any URLs cited

Never return the full text. Never expand beyond the structure above.

The parent gets back 200 words. The full PDF never touches its context.

2.4 A Few More Techniques that Pay for Themselves on Long Sessions

• Load lean. Disable unused MCP servers, tools, skills, and plugins. Move rules out of CLAUDE.md and into skills, custom tools, or referenced .MD files (progressive disclosure).

• Spec prompts. Write requests like a spec: file paths, components, expected I/O, constraints. Vague requests burn turns and tokens.

• Skip the search. When you know the file, tag it @ docs/design.md or @ research.md. Claude doesn’t need to grep for what you can hand it directly.

• rtk-ai/rtk. CLI proxy that strips redundant whitespace and compresses tool output. 60-90% according to the authors. ~20-30% token reduction in my workflow.

  

• juliusbrussee/caveman. Drops conversational filler from responses without affecting the model’s actual reasoning. Highest savings on chats.

  

Subscribe now

3. Wrong Model or Effort

Three separate dials. All burn tokens fast if you leave them on the wrong setting.

3.1 Effort

Default reasoning burns ~2× the tokens of medium for most tasks. Set it on the prompt that needs the headroom, not the whole session.

markdown

/effort low       # quick fixes, mechanical tasks
/effort medium    # most prompts (huge savings vs default)
/effort high      # demanding reasoning 
/effort xhigh     # default for agentic coding (4.7)
/effort max       # diminishing returns; rarely worth the ~2× xhigh cost

Per prompt, not per task or session.

3.2 Route in (CLAUDE.md)

Pick the session model at start. You can’t switch mid-session without nuking the cache (§1). Two options:

• Sonnet session. Cheaper, but no Opus available. Good when you know the work is in-scope for Sonnet.

• Opus session + delegate. Pay for Opus on the parent (planning, tradeoffs), delegate the rest. My default for mixed work.

Then spell out delegation in CLAUDE.md: Haiku for mechanical work, Sonnet for scoped research, Opus for tradeoffs. Opus 4.7 delegates less than 4.6, so you have to ask. See § 2 (Task Delegation) for the full block.

3.3 Route Out

If you’re hitting Pro / Max / Team limits but want to keep the Claude Code interface, route to OpenRouter or another provider. GLM-5.1 ≈ Opus at ~1/12× the cost.

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://openrouter.ai/api",
    "ANTHROPIC_AUTH_TOKEN": "{YOUR-API-KEY}",
    "ANTHROPIC_API_KEY": ""
    },
  "model": "z-ai/glm-5.1"
}

Subscribe now

4. Wrong Input Format

Some inputs are token-expensive by default. Three swaps cover most of it.

4.1 Screenshots and Chrome Scraping → agent-browser

vercel-labs/agent-browser browses pages via the accessibility tree instead of rendering and screenshotting. ~90% fewer tokens than “Claude in Chrome” when you’re scraping or doing research from web pages.

npm install -g agent-browser
agent-browser install  # Download Chrome from Chrome for Testing (first time only)

4.2 PDFs → pdftotext, Not Claude’s PDF Reader

The Read tool loads PDFs as images, which is expensive. Tell Claude to use ‘pdftotext’ instead of ‘Read’ (works for PDFs on local drive, but not attached to the chat - the latter works in Claude Desktop only).

The CLAUDE.md fragment that codifies defaults from 4.1 and 4.2:

## Preferred Tools

### Data Fetching

1. **WebFetch**: free, text-only, works on public pages that don't block bots.
2. **agent-browser CLI**: free, local Rust CLI + Chrome via CDP. For dynamic pages or auth walls that WebFetch can't handle. Returns the accessibility tree with element refs (@e1, @e2). ~82% fewer tokens than screenshot-based tools. Install: `npm i -g agent-browser && agent-browser install`. Use `snapshot` for AI-friendly DOM state, element refs for interaction.
3. **Notice recurring fetch patterns and propose wrapping them as dedicated tools.** When the same fetch/parse logic comes up more than once, suggest wrapping it as a named tool (e.g. a skill file or a .py script that calls `agent-browser` with the snapshot and extraction steps baked in for that source). Add the entry to `## Dedicated Tools` below and reference it by name on future calls.

### PDF Files

Use 'pdftotext', not the 'Read' tool. Use 'Read' only when the user directly asks to analyze images or charts inside the document. Read loads PDFs as images.

## Dedicated Tools

<!-- List project-specific tools here. For each, link to its skill or script file (e.g. `tools/reddit_fetch.py`). The orchestration logic lives in those files, not here. -->

4.3 Large Repos → Code Graph, Not Raw File Reads

tirth8205/code-review-graph builds a persistent map of your codebase (a knowledge graph). Claude reads only what matters. Claimed 6.8× fewer tokens on reviews, up to 49× on daily coding tasks. I implemented it in accredia.io. Worth noting: it does reduce tokens on specific tasks, not all tokens.

AI coding tools re-read your entire codebase on every task. code-review-graph fixes that. It builds a structural map of your code, tracks changes incrementally, and gives your AI assistant precise context via MCP so it reads only what matters.

5. Watch the Number

Three dashboards, depending on your tier:

5.1 Historical (Pro / Max / Team)

phuryn/claude-usage: Long-term breakdown by session, day, week, and all-time. Use it to find where the spend went.

5.2 Real-Time

Gronsten/claude-usage-monitor: Current 5-hour window + active session tokens, with color thresholds. Use it to know how close you are to your cap right now.

5.3 API: Anthropic’s Own Cache Dashboard (API users)

At platform.claude.com/usage/cache, API only, separate from Pro / Max / Team subscriptions monitoring.

If you can’t see the cache hit rate, you can’t fix it.

🔒 6. An Upgraded Sub-Agents Instructions for Cowork and Claude Code

In §2.2, I shared a Subagents v1.0 block that significantly reduced my tokens in Claude Code, especially with Opus 4.7.

After running it across dozens of sessions, two failure modes kept showing up:

• Subagents with no strategic context returned compliant-but-useless data, forcing the parent to re-spawn with a better brief and pay for the work twice.

• Unverified data silently propagated into the parent agent.

Those two issues were common in Claude, unrelated to tokens.

The block below fixes them by adding the strategic-context layer. Works across Cowork and Claude Code 👇

Read more

Anthropic shipped Claude Opus 4.7 on April 16. The official migration guide puts it plainly: 4.7 “takes the instructions literally” and “will not silently generalize.”

It's not a uniform upgrade. Wins on coding, creative writing, and structured work. Losses on instruction following in vague prompts, multi-turn, and long-context retrieval. The benchmarks show a trade, not a regression. I sort real regressions from preference artifacts and cost mechanics in § 6.

Boris Cherny, Claude Code lead at Anthropic, posted on release day: "It took a few days for me to learn how to work with it effectively."

Why Read This, and Why Now

Reddit calls 4.7 a regression. Arena shows 4.6 winning on instruction following. Anthropic's migration guide says it's working as designed. Boris confirms it's more agentic and precise.

The takes don’t agree because they’re measuring different workflows.

By the end you’ll know:

• The ten moves to make your 4.6 prompts work on 4.7

• Where 4.7’s cost really goes, and the ten highest-ROI levers

• What Cowork and Dispatch users lose vs the Code, and what I use on mobile instead

• How to decide between 4.6 and 4.7 for your own workflow

• You don’t need more instructions. You need better intent.

I’ve had 16+ hours with 4.7 so far. What follows is what changed, what to do about it, and resources section at the end.

Subscribe now

1. What’s New in Opus 4.7

4.6 filled the gaps when your instruction was unclear. 4.7 takes you at your word.

For PMs: if your 4.6 workflow relied on the model “figuring out what you meant,” expect 4.7 to ask more questions, or to do less, or to do exactly what you asked for (which is not what you wanted).

2. Intent: The Universal Unlock

This is the principle: 4.7 rewards clear intent. Everything else in this post is a tactic.

Not longer prompts, not more rules, not a bigger CLAUDE.md. Intent splits into two layers:

• Strategic context is durable: what you’re building, who it’s for, what’s off-limits, what good looks like. Write it once. Put it in CLAUDE.md. It loads every session, progressive-disclosure style, so you’re not paying to reintroduce the project on turn one.

• Per-task intent is variable: what specifically do I want Claude to do right now. You still write this every turn. The gain from CLAUDE.md is that you stop retyping the strategic context on top of it.

The full version (seven components, how they compose) is in The Intent Engineering Framework for AI Agents, published three months before 4.7 shipped:

This is perfectly aligned with Karpathy’s Claude coding post, too:

“Leverage. LLMs are exceptionally good at looping until they meet specific goals and this is where most of the “feel the AGI” magic is to be found. Don’t tell it what to do, give it success criteria and watch it go (...) Change your approach from imperative to declarative to get the agents looping longer and gain leverage.”

Anthropic and OpenAI convergence

Anthropic moved Opus 4.7 toward more literal instruction following. OpenAI updated their December 2025 Model Spec to say “consider not just the literal wording but the underlying intent.”

They’re converging from opposite directions. Anthropic is adding precision to its intent-first model. OpenAI is adding intent inference to its precision-first model. The same skill (engineering intent clearly) is becoming the unlock on both sides.

And Anthropic is already encoding it

Managed Agents (research preview) bakes success criteria and outcomes into the framework itself. I recently covered it here:

The skill of engineering clear intent is what transfers across vendors and models. That’s why it has the longest shelf life right now.

Subscribe now

Side Note: On May 9, we’re launching Hands-On Claude Code Certification. In 4 weeks you will learn everything to ship full agentic products — UI, agentic harness, evals, guardrails, and ops — with Claude Code. Real apps, not demos.

Secure your spot (40% off)

Most students expense this through their companies.

3. The 10 Claude Opus 4.7 Migration Moves

3.1 Front-load intent in CLAUDE.md

You don’t have to retype the strategic context every session. Put it in CLAUDE.md once. Every future session starts with the context already loaded. You still write per-task intent each turn, but you stop paying the “remember what we’re building” tax.

Delegate information the agent doesn’t have to read every session to other files, like strategy.md below:

3.2 Default to Extra high (xhigh)

New effort level between high and max. Anthropic’s own recommendation for coding and agentic work.

max is prone to overthinking. Most “4.7 feels slow” reports trace back to people running max by reflex. Use max only when the problem actually needs deep reasoning.

3.3 Toggle effort mid-task

Effort is per-call, not per-session. max for the hard subproblem. Drop back to high for the rest.

3.4 Regression-test old prompts

New tokenizer. 1.0 to 1.35× more tokens per input. Your 4.6 workflows cost more on 4.7 before you’ve changed a line.

The offset to know about: Anthropic raised rate limits alongside the 4.7 launch:

My perspective: what matters most is cost per correct output token. Test it for your specific product before switching the model.

3.5 Batch questions. Stop drip-feeding.

If you have three questions, ask all three in one message.

On 4.6, clarifying across 3-4 turns worked. On 4.7, each turn adds reasoning overhead on top of literal interpretations from earlier turns.

Treat clarification as an exception, not a workflow.

3.6 Show what you want

Positive examples beat negative rules. According to Anthropic:

• “Like this: ” followed by short examples works.

• “Don’t do this: ” rarely lands and burns tokens trying.

If your prompt has more than three “don’t” or “never” lines, flip them. What does the ideal output look like? Show two examples and cut the rules.

3.7 Delete old progress scaffolding

“Summarize every 3 tool calls.” “Give me a status update before moving on.” “Explain your plan, then execute.” Delete these.

4.7 emits high-quality progress updates natively in long agentic traces:

3.8 Tell it to fan out explicitly

4.7 spawns fewer subagents by default and makes fewer tool calls per task. For parallel exploration, you now have to ask.

Phrasings that work: “spawn subagents in the same turn to investigate X, Y, Z.” Autonomy went up. Default delegation went down.

I also added separate instructions for Dispatch in DISPATCH.md. This file is referenced from CLAUDE.md:

Later, I explain why I started using Dispatch less often.

3.9 Review plans, not diffs

Two different primitives. Don’t confuse them.

• Plan mode (Shift+Tab twice in the Claude Code CLI): inline, surfaces the plan before any code exists in the current session. Use for any change that touches more than one file:

• /ultraplan (CLI only, doesn’t work in VS Code extension): cloud-based plan drafting from the CLI, review in the browser. Plan runs in a remote session while your terminal stays free:

Why this matters more on 4.7: because 4.7 takes intent literally, a small misread in the plan becomes a large misread in the diff. Reviewing a 10-line plan for intent drift takes 30 seconds. Reviewing a 200-line diff for the same drift takes 15 minutes.

My take:

Intent drift compounds. Catch it in the plan.

3.10 Adaptive thinking only

Fixed thinking budgets are gone. Use thinking: {type: 'adaptive'} plus the effort parameter. Old API calls with budget_tokens return HTTP 400. Find and replace before flipping the model flag:

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=16000,
    thinking={"type": "adaptive"},
    messages=[
        {
            "role": "user",
            "content": "Explain why the sum of two even numbers is always even.",
        }
    ],
)

If you’re not an engineer, you don’t need to memorize the syntax. Just give your agent this documentation: https://platform.claude.com/docs/en/build-with-claude/adaptive-thinking.md (remove “.md” for a human-friendly view).

Everything above is the mental model. Below, the execution: 10 highest-ROI moves for 4.7 that actually move the bill, my remote setup, and Cowork/Dispatch gotchas 👇

4. Cost Control on Opus 4.7

$20/month is enough to poke at Claude. It’s not enough to run agents. And 4.7 is more expensive than 4.6 by default. New tokenizer (1.0–1.35× tokens per input), adaptive thinking with generous budgets, high-res vision at 3× tokens.

Ten highest-ROI moves (can cut tokens significantly; in my setup, 60–80%):

Read more

Everyone's covering agents helping you build or do knowledge work. The pattern nobody's explaining: the same primitives are the production runtime.

What you’ll learn:

• The Claude Code primitives that double as a production runtime

• When to pick the Anthropic Agent SDK

• The architecture — one function call replaces an n8n-style workflow

• A full working demo: source code, build prompt, hosting notes

• The gotchas that silently break things

• How to host your Claude Code agents in production

1. The Missing Pattern — Agent as A Callable Component

Two narratives dominate right now:

• Agents as products. Claude Code, Lovable, Cursor. You use them to code or to do your work.

• Agents as infrastructure. Claude Managed Agents, CrewAI, LangGraph.

The pattern sitting between those two is agent as a callable component inside your app.

How does it work?

Your web app handles routing, auth, CRUD, form validation. When a request needs reasoning, you call the agent — which runs in a sandbox with its own CLAUDE.md, skills, and MCP servers.

The part that surprised me: the same .claude/ folder I've been editing every day for months is the deployable unit. There is no translation layer between dev and prod. The CLAUDE.md that guides Claude Code in your terminal is the exact same CLAUDE.md format that runs in production.

Subscribe now

2. The Primitives You Already Use

Five key things. We've discussed most of them in the previous posts about Claude Code and Cowork:

• CLAUDE.md — the agent’s identity in markdown. Tone, rules, constraints. In dev it shapes how Claude Code behaves in your terminal. In prod it loads as the system prompt of your production agent. Edit the file, ship the behavior.

• Skills (.claude/skills/) — reusable behaviors, also markdown. Same file format in dev and prod. Same loader.

• MCPs (.claude/mcp.json) — servers that extend the agent’s tool surface. Your dev config probably talks to Chrome and your filesystem. Your production agent’s config talks to your search API and your database. Different servers, identical contract.

• Hooks — functions that fire on tool events. PreToolUse can block dangerous operations (reading .env, path traversal). PostToolUse can log everything the agent read so you can show it in the UI.

• Sub-agents (.claude/agents/<name>/) — each directory is a self-contained agent: its own CLAUDE.md, its own skills, its own MCP config, its own docs. Adding a second agent to your product is a new folder.

Everything is files. Everything is version-controlled. Everything diffs cleanly in a PR. If you've onboarded to Claude Code, you've already onboarded to the production stack.

In case you wondered, here’s a bigger picture:

Subscribe now

3. Why This Matters in Production

Here’s how it stacks up against the alternatives:

Four things fall out of this that I didn't expect going into the spike:

• Nothing new to learn. The CLAUDE.md you wrote in dev is the CLAUDE.md that ships. Your muscle memory is already the production runtime.

• You can skip Claude Managed Agents unless you actively need a hosted runtime. For request-response agents inside an app you already host, the SDK is a smaller dependency than a whole platform.

• Full observability. Hooks give you live per-response metadata — cost, duration, files read — for your UI. OTEL exports full traces to Langfuse or any OTLP backend when you need it.

• Same loop, dev → prod. The config you tested in Claude Code is the config running in production. If it worked in your terminal, it works in your app. No mental translation.

For PMs: this is what lets you prototype and ship agent features without becoming a bottleneck. Changing the agent's behavior is editing a markdown file — not a sprint, not a code review, not a redeploy cycle. You iterate on AI behavior at the speed you iterate on a Notion doc.

Now the part most people skip — how you actually wire it up.

4. The Architecture — One Function Call Replaces a Workflow

In n8n you wire it up node by node. A single agent has system prompt, LLM, model, tools, and memory.

A single Claude agent isn’t a workflow. Inside an app, you don’t need a node-by-node graph around it — simple orchestration and guardrails live in your hooks or your business logic.

In the SDK it's this:

for await (const msg of query({
  prompt: question,
  options: {
    cwd: './.claude/agents/knowledge-agent',
    settingSources: ['project'],
    allowedTools: ['Read', 'Glob', 'Grep'],
    maxTurns: 5,
    maxBudgetUsd: 0.15,
    model: 'claude-sonnet-4-6',
    hooks: { /* guardrails */ },
  },
})) {
  // stream text to the user, collect metadata
}

settingSources: ['project'] is the auto-loader. It reads the agent's CLAUDE.md, skills, and MCP config from agent’s working directory (cwd). Same behavior Claude Code has when it opens a session. You don't manually load anything.

The boundary is clean. Your app owns the request lifecycle, auth, storage. The agent owns reasoning, tool selection, iteration. One function sits on the seam. That's the entire orchestration layer.

Share

5. The Demo — Knowledge Chatbot

I built the smallest thing that shows the pattern: a web app with markdown files and a chatbot that answers questions using those files, with memory across turns.

The agent lives in its own directory:

Stack:

• Next.js 15 standalone (not serverless — the SDK spawns a full Claude Code runtime, not a lightweight API client).

• SQLite for conversation memory because this is a prototype. Postgres, Redis, a JSON file on disk — all fine.

Adding a second agent? New folder in .claude/agents/. Give it a CLAUDE.md. Point cwd at the new directory. Same structure every time.

Keep reading for:

• The prompt that scaffolds the app — paste into an empty repo, Claude Code builds the rest.

• Full source code — Knowledge Chatbot, streaming responses, per-message cost metadata.

• The lib/agent.ts wrapper with the TypeScript pitfalls the SDK docs skip

• The postbuild trick that stops production from inheriting your repo’s CLAUDE.md.

• The limitations I hit in the spike and the workarounds for each.

• How to easily host this in production.

Read more

I run Claude Code on a Max plan. 440 sessions last month, 18,000 turns. I built a dashboard to track what that actually costs: $1,588 in API-equivalent tokens. Covered by a $200 subscription.

Here’s the full breakdown — what April 4 killed, which API models actually work for agentic coding, and how to see exactly where your budget goes.

What You’ll Learn

• What April 4 actually killed — which tools lost subscription access and why Anthropic pulled the plug

• The full cost landscape — subscriptions and API models in one table, ranked by the metric that actually predicts agentic performance

• Why SWE-bench is misleading — it didn’t match my experience. Agentic Index did.

• OpenRouter setup: two environment variables, 400+ models, done

• Token visibility: an open-source dashboard that shows exactly where your Claude Code tokens go

Subscribe now

1. The April 4 Policy Change: What Died, What Lives

April 4, 2026: Anthropic announced Claude subscriptions no longer work with third-party tools. If you were using Cline, Cursor, Windsurf, OpenClaw, or any non-Anthropic harness through your subscription — it stopped working.

What Still Works with Subscriptions

• Claude Code CLI — Anthropic’s official agentic coding tool

• Claude Code extension for VS Code — same mechanism

• Claude.ai — web and mobile interface, including agentic Code sessions

• Cowork — user-friendly agent inside Claude Desktop

• Dispatch — the orchestration layer for Cowork and code

What Died

• Cline — popular VS Code agent, relied on subscription auth

• Cursor — AI-native editor, subscription routing cut off

• Windsurf — Codeium’s editor, same story

• OpenClaw — open-source Claude Code alternative with 135,000+ instances

• Custom agents and automation — anything routing through subscription billing

For automation workflows (n8n, OpenClaw, custom agents): You’re on API billing now. The next section shows you exactly what that costs — and why it might actually be cheaper than you think.

—

OpenClaw footnote: A community workaround briefly routed OpenClaw through Claude Code’s MCP bridge. Anthropic closed it — one exact substring match to block OpenClaw’s system prompt.

2. The Full Cost Landscape

Many builders and PMs either overpay for a subscription they don’t fully use, or overpay for API models because they default to Sonnet. Here’s everything in one place.

Claude Subscriptions: Flat Cost, Predictable

Every tier requires discipline. Opus burns credits ~5x faster than Sonnet, so use Opus for hard problems and switch to Sonnet for straightforward tasks. Run /compact regularly. Without this, you’ll hit limits on any plan — including Max 20x.

How cheap is this compared to API? My Max 20x costs $200/month. The dashboard I built (Section 4) shows $1,588 in API-equivalent costs for Claude Code alone — and I use Code and Cowork roughly 50:50, so the real API bill would be far higher. The Claude subscription runs roughly 15-30x cheaper than paying per token for the same work.

Teams and Enterprise subscribers: If your company already provides Claude Teams or Enterprise, you have Claude Code access included. Check with your admin — you may not need a personal subscription at all.

API: Pay Per Token, Choose Your Model

OpenRouter gives you access to 400+ models. Most aren't worth your time for agentic coding. I tested dozens — the table below is what survived real multi-step Claude Code sessions, ranked by Agentic Index:

Why Agentic Index?

• SWE-Bench (Verified and Pro) tests isolated bug fixes — one issue, one patch, no iteration. It didn't match my experience.

• Agentic Index (from Aider's polyglot benchmark) measures what Claude Code actually does: read files, plan changes, apply diffs, run tools, recover from errors, iterate. It matched what I saw in practice.

Claude Subscription vs API

Subscription wins if you code with Claude Code daily. Opus is the best agentic model — and cost per token isn’t cost per correct token. A cheaper model that needs many iterations to fix its own errors costs more than Opus getting it right the first time. Cowork, Dispatch, and web-based Claude Code sessions also require a subscription.

API wins if your usage is moderate, spiky, or you’re running automation workflows. Opus and Sonnet via API are hard to justify when the subscription gives you flat-rate access — and budget models match or beat Sonnet’s agentic performance:

• GLM-5.1 — matches Opus 4.6 on agentic performance (67.0 vs 67.6) at 1/12x the input cost. Default for automation.

• GLM-5 — same family, cheaper. Matches Sonnet’s 4.6 agentic score at 1/4x the cost.

• MiniMax M2.7 — when cost matters most. 1/10x Sonnet’s 4.6 score. Still solid.

One Thing Missing: Token Visibility

The subscription model has one real frustration: you can't see where your tokens go. /usage exists but doesn't break down by model, project, or session — so when you hit limits unexpectedly, it's not obvious why.

Anthropic knows: there are open feature requests for per-prompt token breakdown and a real-time usage indicator. I built an open source solution — Section 4 covers it.

Subscribe now

3. OpenRouter Setup for Claude Code

Claude Code isn’t locked to Anthropic’s models. Switch ANTHROPIC_BASE_URL and it routes to any compatible API. Add a .claude/settings.local.json to your project root, for example:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://openrouter.ai/api",
    "ANTHROPIC_AUTH_TOKEN": "sk-or-v1-{your-OpenRouter-API-key}",
    "ANTHROPIC_API_KEY": ""
    },
  "model": "z-ai/glm-5.1"
}

Why OpenRouter over direct provider APIs?

One key, one endpoint, 400+ models. Switch between GLM-5, Qwen, Gemini, and GPT-5 by changing one variable—no juggling multiple API keys or base URLs.

Switching the API works for Claude Code CLI, but not for Claude Code Extension. In practice, this doesn’t make a huge difference, as you can still work with VS Code interface.

Step-by-step demo:

Side Note: Want to build with Claude? Join our AI Agents Claudathon — in 4 weeks you will learn everything to ship real agentic products with Claude Code. No experience required:

Learn more

P.S. This is not an external cohort. Just me and .

4. Claude Code Usage Dashboard: See Where Your Tokens Go for Free

I mentioned the visibility gap in Section 2 — /usage doesn’t break down by model, project, or session. You hit limits and have no idea why.

That frustrated me enough to build something.

I open-sourced a local dashboard that reads your Claude Code transcripts and shows you exactly where tokens go. No cloud, no telemetry — everything stays on your machine:

You can star it, fork it, and make it your own. GitHub (open source, MIT):

Claude Code Usage Dashboard

What It Shows

• Cost per day, broken down by model (Opus vs Sonnet vs Haiku)

• Sessions and turns over time

• Filter by model, filter by time range (7d / 30d / 90d)

• Top projects by tokens — see which codebase is eating your budget

• Auto-refreshes every 30 seconds at localhost:8080

My 30-Day Numbers

440 sessions. 18,000 turns. $1,588 in estimated API costs.

All covered by the Max subscription. For a fraction of the price.

First thing the dashboard caught: one day spiked to 700 million cached tokens. Not my usage — an Anthropic bug. Without the dashboard, I’d never have noticed.

Setup & Run on Windows

git clone https://github.com/phuryn/claude-usage
cd claude-usage
python cli.py dashboard

Setup & Run on MacOS, Linux

git clone https://github.com/phuryn/claude-usage
cd claude-usage
python3 cli.py dashboard

What It Measures

Claude Code Usage Dashboard works with any Claude subscription (Pro, Max, Team, Enterprise) running Claude Code — CLI, VS Code extension, and dispatched code sessions.

At the same time, Cowork and web code sessions are not included. We need to wait for Anthropic for a better solution.

5. Token-Saving Techniques (Works Everywhere)

Before switching models or tools, optimize what you’re already doing. These apply whether you’re on subscription or API.

Use /compact Aggressively

Context accumulates fast. Every file read, tool call, and response adds tokens. A 30-minute session easily hits 200K tokens, and you’re paying for all of it on every subsequent message.

Run /compact after major milestones. It preserves intent and drops noise.

Don’t Use Opus for Everything

Opus 4 costs 5x more than Sonnet ($15/$75 vs $3/$15 per M tokens). For most coding tasks, Sonnet is equivalent—and GLM-5.1 matches Opus on agentic tasks at 1/12th the cost.

If you struggle with available tokens, use Opus only for:

• Complex architectural reasoning when Sonnet keeps failing

• Long-context analysis where every detail matters

• Tasks with extreme ambiguity

Default to Sonnet or GLM. Escalate to Opus when the model fails.

Watch for MCP Tool Overhead

MCP tools can easily add ~20K tokens to every session just from tool definitions.

While by default they are loaded on demand in Opus and Sonnet, this may not work with custom LLMs. Remove MCP servers you don’t need by typing /mcp in Claude Code CLI.

Hint: This is where you can adjust default settings for Opus and Sonnet:

  {
    “env”: {
      “ENABLE_TOOL_SEARCH”: “true”
    }
  }

Code Graph MCP: Feed Claude Only What It Needs

Every time Claude Code reviews a change, it searches your codebase with grep and glob — smart, but not structural. It doesn’t know which functions call what.

code-review-graph adds that structural layer. It parses your codebase into an AST, stores it in SQLite, and tracks changes via git hooks. At review time, it traces the blast radius of your change and feeds Claude only the affected files.

The author’s benchmarks: 6.8x fewer tokens on code reviews, up to 49x on daily coding. On a 27,700-file monorepo, only 15 files were read.

I haven’t tested these numbers myself, I currently don’t work with such large codebases, but the architecture makes sense — especially for large codebases where the savings compound.

Agent-Browser: Browse Without Screenshots

If your agents need browser access, don’t use Chrome MCP with screenshots — each screenshot eats thousands of tokens for a single page view.

agent-browser by Vercel Labs takes a different approach: instead of screenshots, it returns an accessibility tree snapshot with element references (@e1, @e2, etc.). Agents interact via those refs — compact text, not images. The result: 82% fewer tokens than Playwright MCP, up to 93% reduction overall.

It’s also much more reliable than the standard web fetch:

No configuration needed. Works with Claude Code (tell it to use it in CLAUDE.md) and any MCP-compatible agent. Installation:

npm install -g agent-browser

Subscribe now

8. Closing

Subscribe for daily coding — stop watching the meter. Route automation to GLM-5.1 for Opus-level agentic performance at 1/12th the cost. Track every token with an open-source dashboard so you know exactly what you’re getting.

Anthropic’s April policy change forced automation users onto API billing. But it also clarified the landscape: subscriptions for Anthropic tools, APIs for everything else.

The one thing still missing: real token visibility from Anthropic. Until they ship it, the dashboard fills the gap. Clone it, see where your tokens go, and stop guessing:

Thanks for Reading The Product Compass

It’s amazing to learn and grow together.

Next: prototyping for PMs (3 tools & templates). This will be a paid content.

Have a great week ahead,
Paweł

What You’ll Learn:

• A Knowledge Architecture block that turns Claude into a system that learns across sessions — not just a tool that forgets

• A Decision Journal block that logs every meaningful choice with full reasoning, so Claude (and your team) never re-debates settled decisions

• A Quality Gate block that gives Claude concrete evaluation criteria — because agents can’t objectively judge their own work

• A schedule suggestion that keeps the whole system from going stale

• The full integrated CLAUDE.md — all three blocks ready to paste

0. Memory Without Reflection

Claude remembers. It writes its own memories, reads your CLAUDE.md, follows your conventions. But it doesn’t reflect on what it knows.

It captured that your pricing test showed 40% churn. It captured that a competitor dropped their free tier. It captured that onboarding users churned less. Three separate observations in three separate sessions — and Claude never connected them.

Memory without reflection is just storage.

Claude now ships with built-in configuration — the .claude folder, settings files, rules. Boris Cherny, the creator of Claude Code, shared how his team uses CLAUDE.md internally — every correction becomes a rule, checked into git.

That’s a good foundation. But it’s a correction log. The system doesn’t promote patterns on its own. It doesn’t test its own hypotheses. It doesn’t evaluate whether its work meets project-specific standards.

The community has built impressive tooling on top of this. Some repositories catalog 135+ agents, 42 commands, and hundreds of plugins. Powerful systems for teams that want deep infrastructure.

Most builders need something they can paste in 90 seconds that makes Claude measurably better by next week.

Three blocks. Each one targets a different failure mode — learning, deciding, evaluating. Together, they turn memory into a system that reflects, connects, and compounds.

Subscribe now

1. Knowledge Architecture — The Learning Loop

The problem: Claude captures observations but never revisits them. Insights from last week's session don't inform this week's work. There's no mechanism to test whether a pattern holds, promote it when it does, or discard it when it doesn't.

The snippet:

Before starting a new task, review existing rules and hypotheses for this domain.
Apply rules by default. Check if any hypothesis can be tested with today's work.

At the end of each task, extract insights. Store them in domain folders, e.g.:
  /knowledge/pricing/         (or /onboarding/, /competitors/)
    knowledge.md  (facts and patterns)
    hypotheses.md (need more data)
    rules.md      (confirmed — apply by default)

Maintain a /knowledge/INDEX.md that routes to each domain folder.
Create the structure if it doesn't exist yet.
When a hypothesis gets confirmed 3+ times, promote it to a rule.
When a rule gets contradicted by new data, demote it back to hypothesis.

How it works: Before every task, Claude reads the existing knowledge — active retrieval, not passive storage. The value isn't in the files. It's in Claude checking them mid-session before making a recommendation.

After a month, I had a folder with 24 rules Claude applied automatically. I didn’t write those rules. They emerged from dozens of sessions. Claude was measurably better than day 1 — not because of better prompts, but because the system had been learning the whole time.

Want to build with Claude? Join our AI Agents Claudathon — ship real agentic products with Claude Code. No experience required. Limited to 60 students.

Learn more

2. Decision Journal — Reviewable Reasoning

The problem: Someone asks why you picked Postgres over DynamoDB. Or why you killed the freemium tier. Or why the onboarding flow skips the team invite step. Nobody remembers. So you spend 30 minutes re-debating a decision that was already made.

The snippet:

When about to make a decision that affects more than today's task,
first grep /decisions/ for prior decisions in that area. 
Follow them unless new information invalidates the reasoning.

If no prior decision exists — or you're replacing one — log it:

File: /decisions/YYYY-MM-DD-{topic}.md

Format:
  ## Decision: {what you decided}
  ## Context: {why this came up}
  ## Alternatives considered: {what else was on the table}
  ## Reasoning: {why this option won}
  ## Trade-offs accepted: {what you gave up}
  ## Supersedes: {link to prior decision, if replacing}

How it works: If you’ve worked with Architecture Decision Records, this will feel familiar — same principle, enforced by Claude instead of team discipline.

When decisions get replaced, the Supersedes field creates a traceable chain. suggested this addition and the retrieval-first ordering, and both made the journal sharper.

A month in, the patterns surprised me. The decisions I was most confident about had the worst hit rate. The ones where I forced myself to write out three alternatives before choosing were right 80% of the time.

Keep reading with a 7-day free trial.

What’s inside the paid section:

• The third block — Quality Gate — and why Claude can’t evaluate its own work without it

• A self-maintenance instruction that keeps the whole system from going stale

• How the three blocks reinforce each other (the compounding thesis)

• The full integrated CLAUDE.md — all three blocks + schedule suggestion, ready to paste

3. Quality Gate — Evaluation Criteria That Compound

The problem: Claude finishes a task and tells you it’s done. You ask if the work is good. Claude says yes — confidently, every time.

Anthropic’s own engineering team documented this: when asked to evaluate work they’ve produced, agents confidently praise it — even when the quality is mediocre. The agent that built the thing can’t objectively evaluate the thing.

Read more

I mapped every release since February 1st to a shipping calendar — dates, features, team attribution. Not by reading changelogs. By going through the feeds of the people actually shipping.

What stands out isn't any single feature. It's the velocity across every surface at once:

→ Developer tools (Claude Code) — 28 releases
→ Desktop automation (Cowork) — 15 releases
→ API and infrastructure — 18 releases
→ Models and core platform — 13 releases

No team is waiting for the other. They're all shipping in parallel:

For PMs, this creates a compounding gap. Every week you don’t explore Dispatch, Scheduled Tasks, or Computer Use is a week someone else does. The PM who builds a self-improving CLAUDE.md system today has an automation layer that gets better with every release. The PM who waits builds from scratch each time.

This isn't about picking the "best AI tool." It's about recognizing when one platform's shipping velocity makes the decision for you.

My Claude Guides

If you want to go deeper on any of these surfaces, I’ve written complete guides for PMs:

• Claude Cowork Guide for PMs — the desktop agent that works with your files, apps, and connectors

• Claude Code: The Complete PM Guide — the CLI/IDE agent for technical work

• The Self-Improving Claude AI System — how to build a knowledge system that compounds across sessions

• The Claude Dispatch Guide for PMs — the always-on persistent agent that runs while you’re away

Subscribe now

Timeline & Everything You Might Have Missed

Feb 3 – Feb 9

CC Session Sharing: Share Claude Code sessions with teammates for collaborative debugging and pair programming.

Cowork Slack MCP on Paid Plans: Access Slack messages, channels, and search directly from Cowork on all paid plans.

Cowork GSuite Connectors: Connect Gmail, Google Calendar, and Google Drive to Cowork for cross-app workflows.

CC /insights Command: Get AI-generated analysis of your codebase’s architecture, patterns, and dependencies.

CC Agent Teams: Spawn multiple Claude Code agents that work in parallel on different parts of a codebase.

CC /debug Skill: Auto-diagnose failing tests and runtime errors with a dedicated debugging workflow.

Opus 4.6: New flagship model with improved reasoning, coding, and instruction-following across all Claude surfaces.

CC /rewind: Press ESC twice to summarize and compress your conversation context instead of losing it.

CC Fast Mode: Optimized response mode that trades depth for speed on routine coding tasks.

Fast Opus 4.6: Early preview of Opus 4.6 running 2.5x faster than the standard version.

Feb 10 – Feb 16

Cowork for Windows: Cowork desktop app now available on Windows alongside the existing Mac version.

CC --dangerously-skip-permissions: Run Claude Code with auto-approved tool use for fully autonomous, unattended workflows.

CC Contribution Metrics: Track how much code Claude wrote versus you across your project’s history.

Free Plan Expansion: Free users get file uploads, connectors, and skills in Cowork.

Cowork Folder Instructions: Drop a CLAUDE.md file into any folder to give Cowork persistent, project-specific context.

CC Slack App (Plan Mode): Use Claude Code’s plan mode directly from Slack to scope technical work before executing.

CC Desktop Local Plugins: Install and run local MCP-based plugins on the Claude Code desktop app.

CC Multi-Repo: Work across multiple repositories in a single Claude Code web session.

CC SSH Support: Connect the Claude Code desktop app to remote development machines over SSH.

Subscribe now

Feb 17 – Feb 23

Sonnet 4.6: New mid-tier model balancing speed and quality, available across all Claude surfaces.

CC Sonnet 4.6 Support: Sonnet 4.6 available as a selectable model option in Claude Code with early benchmark results.

CC Figma MCP: Push Claude Code outputs directly into Figma for design-development handoff.

Claude in PowerPoint: Create and edit PowerPoint slides directly within the Claude interface on Pro plans.

CC Security (Research Preview): Automated security scanning that identifies vulnerabilities in your codebase before they ship.

CC Desktop Preview Apps + CI/PRs: Preview running applications and handle CI/CD and pull request workflows from the desktop app.

CC Worktrees: Built-in git worktree support so agents can work on parallel branches without switching context.

Feb 24 – Mar 2

CC Remote Control: Control Claude Code sessions from your phone — review, approve, and guide agents on the go.

Enterprise Customize + Marketplaces: Enterprise admins can customize Claude behavior and create private plugin marketplaces for their org.

Cowork Scheduled Tasks: Schedule recurring Cowork tasks that execute automatically on a cadence you define.

CC Auto-Memory: Claude Code automatically remembers your preferences, codebase patterns, and project context across sessions.

CC Claude for Open Source: Free Claude Code access for qualifying open source project maintainers.

CC /simplify + /batch: Refactor complex code into simpler patterns (/simplify) or run the same operation across many files at once (/batch).

CC AskUserQuestion Snippets: Claude Code shows formatted markdown previews with code snippets when asking you clarifying questions.

Memory on Free Plan: Persistent memory across conversations now available to all free-tier Claude users.

Mar 3 – Mar 9

Voice Mode: Talk to Claude Code using push-to-talk voice input instead of typing commands.

CC HTTP Hooks: Fire HTTP webhooks on Claude Code events — connect sessions to Slack, CI pipelines, or any external system.

CC Local Scheduled Tasks: Schedule recurring tasks that run automatically on your machine while your computer is awake.

Enterprise Marketplace: Enterprise customers get a curated marketplace of approved plugins and integrations for their org.

CC /loop: Set Claude Code to continuously iterate on a task — building, testing, and fixing in a loop until your tests pass.

CC Auto Mode: Claude Code automatically selects the right execution approach without requiring manual mode switching.

CC Code Review (Multi-Agent): Multiple Claude agents analyze your pull request in parallel, each reviewing different aspects of the code.

Mar 10 – Mar 16

CC /btw: Send Claude a side note mid-task without interrupting its current work — corrections, context, or new info.

CC /effort: Control how deeply Claude thinks — from quick one-shot responses to extended multi-step reasoning.

Cowork Excel + PowerPoint Sync: Edit Excel spreadsheets and PowerPoint decks in Cowork with cross-file synchronization.

Interactive Charts: Claude can now build interactive charts, diagrams, and visualizations directly in chat. HTML-based, editable, available on all plans.

Rich Text Output: Claude no longer defaults to plain text — responses now include interactive charts, formatted tables, and rich media.

CC Setup Scripts: Add a setup script that runs automatically when Claude Code initializes in your project directory.

Voice Mode on Desktop + Cowork: Push-to-talk voice input now available on the Claude desktop app and in Cowork sessions.

1M Context Window GA: One-million-token context window generally available across all paid Claude plans.

CC Opus 1M Default: Opus 4.6 with 1M context is now the default model in Claude Code.

CC Session Spawning: Spawn new local Claude Code sessions directly from the mobile Remote Control app.

CC /color: Customize your Claude Code terminal with color themes and visual preferences.

CC Review Manual Trigger: Type @claude review in any PR comment to trigger a multi-agent code review on demand.

CC MCP Elicitation: MCP servers can now ask Claude Code for additional context during tool execution instead of failing silently.

2x Usage: Double usage limits during off-peak hours for all paid plan subscribers.

Subscribe now

Mar 17 – Mar 23

Cowork Dispatch: A persistent, always-on Claude conversation that runs on your computer — continues working even when you close the app.

CC Output Tokens 64K: Maximum output token limit increased to 64K for longer generated code and responses.

Opus 1M on Desktop: Opus 4.6 with 1M context now available on the desktop app for Max, Teams, and Enterprise users.

Dispatch + CC Sessions: Dispatch can now launch and manage full Claude Code sessions alongside its standard Cowork tasks.

CC Shell in SKILL.md: Embed live shell command outputs directly in skill files using !command syntax for dynamic context.

Claude.ai Speed Boost: Claude.ai and desktop apps load significantly faster after migrating from SSR to Vite + TanStack Router.

CC VSCode Remote: Use Remote Control to manage Claude Code sessions running inside VS Code from your phone.

CC Skills over Remote Control: Run skills and slash commands from your phone via Remote Control — full command access on mobile.

CC Channels (Telegram + Discord): Connect Claude Code to Telegram and Discord — interact with your coding agent from messaging apps.

CC Cloud Scheduled Tasks: Schedule recurring Claude Code tasks that run in the cloud — no local machine required.

Projects in Cowork: Organize Cowork conversations into named projects for better context separation and management.

CC DOM Element Selection: Select DOM elements directly from a running application to reference them in Claude Code conversations.

CC Effort in Skills: Set effort levels directly inside skill and slash command definitions to control reasoning depth per task.

CC /loop 7 Days: Loop sessions now run for up to 7 days instead of the previous 3-day limit.

CC /init v2: Redesigned project initialization that interviews you about your codebase before generating CLAUDE.md configuration.

CC /schedule Cloud: Schedule cloud-based tasks directly from the /schedule command — tasks run on Anthropic’s infrastructure.

Computer Use: Claude can now control your computer directly — mouse clicks, keyboard input, and screen reading for end-to-end automation.

CC Channels Permission Prompts: Channels now support permission prompts so you can approve sensitive actions from Telegram or Discord.

Mar 24 – Mar 30

CC Channels for Teams + Enterprise: Channels (Telegram, Discord integration) now available for Teams and Enterprise plans.

And the week continues.

[Edited] Here we go, not included in the infographic:

CC Auto Mode (Research Preview): Claude autonomously handles permission prompts during coding. A pre-execution classifier reviews every tool call, blocking destructive operations and prompt injection. Enable with `claude --enable-auto-mode`.

P.S. Glad Claude Team noticed this. Noah is the legend:

Subscribe now

Have a great rest of the week,
Paweł

Dispatch is the newest surface — and the one most likely to change how you work as a PM. Not because it’s the most powerful, but because it turns every gap in your day into a window for directing real work. Dog walks, coffee, the passenger seat, standing at the sidelines of a bounce house — all become productive without being “always on.”

I tested this for 48 hours straight, building real PM workflows from my phone. What you’re reading is everything I found — the workflows that actually work, the friction points nobody warns you about, and the architectural insight that matters more than any single feature Anthropic ships.

What You’ll Learn

• What Dispatch actually is — and the difference from “Claude chat on your phone”

• How to set up and start your first Dispatch session

• The real 48-hour timeline — how async direction reshapes your day

• Every gotcha I hit, with tested workarounds

• When to use Dispatch vs. Web Sessions vs. Channels vs. Code

• Why the knowledge layer matters more than any single surface

• The single highest-leverage investment for PMs building with AI

If you haven't read the earlier parts of this series, they help but aren't required — this post stands alone:

• Claude Cowork Guide — the desktop agent Dispatch controls remotely

• Claude Code: The Complete PM Guide — how to start

• The Self-Improving Claude System — the knowledge architecture that makes all of this compound

Subscribe now

1. What Dispatch Is (And Isn’t)

Dispatch isn’t “Claude chat on your phone.” You already have that.

Dispatch is an orchestrator. From a single conversation on your phone, you spawn and manage multiple Cowork task sessions running simultaneously on your desktop. Each session runs independently — its own context, its own file access, its own connectors.

Your phone is the command chair. Your desktop does the heavy lifting.

Think of the difference between texting someone a request and sitting in a control room with multiple screens. Each screen is a task session running on your desktop. Your phone directs all of them from one conversation thread.

For PMs: This maps to something you already do — running multiple workstreams simultaneously. One analyst pulling competitor data. Another drafting the stakeholder email. A third organizing research notes. Dispatch is that, except the analysts are AI sessions on your desktop and the command chair is in your pocket.

Every Cowork connector you've configured — Gmail, Notion, Slack, all of them — works through Dispatch because Dispatch delegates to Cowork.

Subscribe now

2. How to Set Up Claude Dispatch

Step 1: Set up Cowork on your desktop with the connectors you use — Gmail, Notion, Slack, whatever your stack is. Everything must be configured on desktop first. Then, keep your desktop awake and Claude app running.

Step 2: Open the Claude mobile app. You’ll see the Dispatch tab. Start a conversation and tell it to run a Cowork task.

Step 3: Start small. One task (e.g., “summarize unanswered emails from the last week”). See the output. Then try running two tasks from the same conversation to feel the parallel workflow.

Step 4: To work with files, grant folder access — describe the folder naturally (”go to workspace/editor”) or use a shortcut you’ve defined. Start with the folder that has your CLAUDE.md and knowledge files.

Step 5: Set up your workarounds early:

• If your workspace syncs via Google Drive/Dropbox/iCloud, check that files appear on your phone — this eliminates the file transfer problem entirely

• Define folder shortcuts (”editor mode,” “workspace”) so you describe folders naturally instead of typing paths

3. Real PM Workflows With Claude Dispatch (48-Hour Test)

Dispatch didn't fill my dead time. It changed how I structured my day. I went to the jump arena with my kid because I could direct work async from the sidelines. The model isn't "grind during gaps." It's "design your day differently because the work runs without you sitting in front of it."

Here's what that looked like:

Read more

5.2 million impressions on X. 35,000 likes. 43,000 bookmarks. 7.2% engagement rate. In three months. Most of that growth happened within the last 6 weeks.

Not from writing more. Not from better prompts. From building a system that compounds.

[Edited] After publishing this article:

I'm going to show you what that system looks like, how it evolved, and why the architecture matters more than the content it produces. You can drop the whole structure into Claude and use it directly, or treat it as inspiration to build your own.

I'll use content creation as the case study — but the pattern works for customer research, competitive intelligence, market analysis — any domain where knowledge compounds.

This is Part 3 of my Claude for PMs series. New to the tools? Start with Part 1: Cowork and Part 2: Claude Code.

In this post, we discuss:

1. How Agentic Systems Learn from Real-World Data

2. How a Claude Knowledge System Compounds Over Time

3. Architecture: File-Based Knowledge Graph

4. 2x Usage: The Best Time to Start with Claude

5. What We’ll Learn Next

6. How This AI System Evolved in 3 Phases

7. Building Custom AI Tools with Claude Code

8. Cross-Surface Workflow: Claude Code, Cowork, and Web

9. Hypothesis Tracking: How the System Stays Honest

10. How to Build Your Own Claude Knowledge System

11. Why Self-Improving AI Systems Win

1. How Agentic Systems Learn from Real-World Data

The workflow is simple:

Pull data → organize knowledge → let the system learn → compound over time.

X (Twitter) content is where I tested it. But the same architecture works for:

• Customer interviews — After 50 interviews, the system knows your product’s pain points better than your Confluence page.

• Competitive monitoring — Competitor moves instead of tweets. Pricing changes instead of LinkedIn posts. Patterns across weeks you’d miss manually.

• Market intelligence — Pull from APIs, browser scraping, manual input. Let the system self-correct as the market shifts.

AI handles the repetitive work — the research, the drafting, the data pulling.

What it can't do is decide what matters. That's your job. This system doesn't replace your judgment. It gives your judgment better inputs, faster, and those inputs compound over time.

2. How a Claude Knowledge System Compounds Over Time

The more you use Claude, the more it improves. Structure emerges. Knowledge files build up. It starts feeling less like using a tool and more like building a system that gets better every time you touch it.

I didn’t start with a master plan. I started by pasting screenshots into Cowork, asking “what makes this post work?” Raw, unstructured. Just curiosity.

But Claude started noticing patterns I missed. It flagged that negation hooks outperform positive hooks on LinkedIn. It noticed that data experiments get 3x more bookmarks than opinion posts. It spotted that my builder-teacher posts consistently outperform my analyst takes.

Over weeks, the system grew. Claude suggested reorganizing the files into a knowledge hierarchy. Then it suggested building a Python script to fetch tweet data cheaper. Then it started proposing edits to its own knowledge base.

Now the system has 26 content templates, 13 active hypotheses being tested with real data, 50+ catalogued false beliefs (things conventional wisdom says hurt but data shows don’t), and 7 topic lanes with energy tracking — all maintained by Claude, all improving with each use.

But "maintained by Claude" doesn't mean I stepped back. Here's what the collaboration actually looks like — I asked Claude to summarize who contributed what during a real session:

I decide every editorial call — what to post, what to kill, what angle to take, which facts need checking twice. Claude handles research, verification, structural options, and pattern-matching against the knowledge base.

AI compresses execution. The writing, the code, the analysis. What it can’t compress: knowing what to build. Knowing what to cut. Taste. Judgment.

The dev who writes code all day gets compressed. The dev who decides what code should exist becomes more valuable than ever. Same split applies to PMs. Same split applies to content. This is 10+ iterations per post. Not “write me a post about X.”

Share

3. Architecture: File-Based Knowledge Graph

What we built with Claude is a file-based knowledge graph with progressive disclosure. This is where I ended up after months — not where I started. You can drop this structure into Claude and use it as-is, or treat it as inspiration. Paste it in and Claude understands immediately what goes where.

Here’s what my repo looks like today:

Project Structure:

• CLAUDE.md is the brain. It defines the rules, the voice, the workflow. Everything Claude needs to know about how to operate.

• knowledge/INDEX.md is the router. It reads this first, then drills into only the folder that’s relevant to the current task.

• Each subfolder is a knowledge domain:

  • craft/ holds writing techniques.

  • voice/ holds 9 archetypes for matching tone to content.

  • platforms/ holds platform-specific rules, templates, and hooks.

  • posts/ holds performance data from analyzed content.

  • hypotheses/ holds what I’m testing next.

And here's how it flows:

Progressive disclosure means Claude doesn’t load everything. Context windows are finite — even at 1 million tokens, loading everything wastes attention. The system only loads what’s relevant to this specific task.

How to adjust this as a PM: Replace craft/ with discovery/. Replace voice/ with stakeholders/. Replace platforms/ with channels/. Same architecture, different labels.

4. 2x Usage: The Best Time to Start with Claude

Claude is offering double usage limits through March 27. Weekdays outside peak hours, all day on weekends. Automatic across Web, Code, Cowork, and mobile.

It's the best time to start building with Claude.

Subscribe now

5. What We’ll Learn Next

Here’s what’s behind the paywall — and why each piece matters:

• How Claude builds tools for you — Claude Code can call any API and wrap it into a reusable script. No MCP needed. I’ll show you how it works and when to say yes. (If you’ve ever wanted to pull data from an API but didn’t want to write code — this is how.)

• Automating Chrome without the 30-second waits — Claude Code controls your real browser through MCP. Direct DOM access, not screenshots. Setup takes 2 minutes. (If you’ve tried AI browser tools and hated the speed — this is different.)

• From generic prompts to a PM knowledge system — How to structure CLAUDE.md so it actually compounds: learning mode, hypothesis tracking, false beliefs. The principles and key snippets — not my full file, but everything you need to build your own. (If your Claude sessions start from scratch every time — this fixes it.)

• How the system stays honest — Hypothesis tracking that kills bad ideas with data. False beliefs that fight conventional wisdom. And one CLAUDE.md instruction that makes Claude propose improvements on its own. (If you want a system that challenges its own assumptions — this is how.)

• The three phases — How this evolved from pasting screenshots into Cowork to a system that learns. Where to start, what to expect at each stage. (If you’re starting from zero — this is your roadmap.)

• The cross-surface workflow — Same system from Claude Code, Cowork, and web. The tool doesn't matter — the shared context does. (If you've tried Claude in one surface and wondered how to connect them — this is it.)

Read more

The other 30% sounds more technical than it is. This guide walks you through the new interface and shows you what it unlocks.

(Haven't tried Cowork yet? Start with my Cowork guide for PMs. It'll make the transition smoother.)

What Is Claude Code?

Cowork and Claude Code share the same brain. The difference is where they live and what they can touch.

Cowork runs inside Claude Desktop — in a sandboxed VM. It works with files in your selected folder, connects to your apps, and handles knowledge work safely. Optimized for knowledge work — documents, research, and deliverables.

Code runs in VS Code (or the terminal). Same file access, but no sandbox — it runs bash commands directly, manages git, and gives you an Explorer sidebar to navigate your project visually. Optimized for codebases, prototyping, and engineering workflows.

The name is misleading. “Claude Code” sounds like it’s only for developers. It’s not. At Anthropic’s latest hackathon, an attorney, a cardiologist, and a roads worker won the Claude Code hackathon:

They won because they understood their problems deeply — and Code removed the friction between the idea and the build.

Why Bother with Claude Code?

Cowork is fantastic for knowledge work — email drafts, file creation, research, presentations. But you'll hit moments where it's not enough.

• You want to prototype. Cowork creates documents. Code creates working software. PRD to working demo in a single session. That’s what Anthropic PMs already do — they prototype in Claude Code instead of writing specs and waiting for engineering. Plan Mode lets you review before Claude changes anything.

• You want context that compounds. Cowork sessions start fresh (we discussed how to fix that). Code now has Auto Memory — it saves your patterns, preferences, and decisions across sessions.

• You’re working with engineers. Code speaks git natively. Prototype a feature, push to a branch, create a PR.

You can achieve some of the above in Cowork by installing developer plugins and Desktop Commander and adding custom instructions, but Cowork was not designed for those jobs.

If you only need email drafts, research results, and presentations, you can stay in Cowork. But if you’ve ever thought “I wish I could just build this myself” — Code is the bridge.

In this post, we discuss:

1. The Transition to Claude Code: Step by Step

2. What Genuinely Changes

3. Claude Code - Three Extra Tips

4. PM Power Moves

5. Honest Caveats — Where Cowork Is Still Better

6. Going Further — When You’re Ready

7. What’s Next

Subscribe now

1. The Transition to Claude Code: Step by Step

Step 1: Install VS Code

Download VS Code and install it. That’s it — no terminal commands, no configuration files. It’s a free editor that works on Windows, Mac, and Linux.

Step 2: Install the Claude Code Extension

Open VS Code, go to Extensions (Ctrl+Shift+X), search for “Claude Code” and install it.

Important: If you have GitHub Copilot Chat extension enabled, disable it. Having both active may create confusion when you start — two AI assistants competing for the same sidebar. Claude Code is the one you want.

Step 3: Connect Your Anthropic Account

You have two options:

• Subscription (most likely): You probably already have Claude Pro or Max. Claude Code will prompt you to sign in on first use — it opens a browser window, you log in with your claude.ai account, approve the connection, and you’re done. Your subscription usage applies.

• API key (pay-per-use): Go to console.anthropic.com → API Keys → Create Key. Then in VS Code: Command Palette (Ctrl+Shift+P) → “Claude Code: Set API Key” → paste it. You’re billed per token instead of a flat subscription.

Your web connectors (Gmail, Slack, Notion, etc.) carry over automatically from Cowork — they’re tied to your account, not to a specific app.

Step 4: Open Your Cowork Folder

File > Open Folder > navigate to the folder you’ve been using with Cowork.

Your CLAUDE.md is already there. The same instructions you wrote for Cowork work in Code. Claude reads them at the start of every session, just like before.

Step 5: Orient Yourself: What You’re Looking At

For comparison, this is what we saw in Cowork:

Here's what you see in VS Code:

Here’s what you see:

• Left panel: Explorer. Your files and folders — always visible, always navigable. This is what makes Code feel different from Cowork.

• Right panel: Claude Code extension. This is where you talk to Claude.

• Middle panel: A dedicated Claude Code CLI window. It's there when you want more control, e.g., configure local MCP servers. Don't start with it — the extension UI is easier.

• Bottom panel: System Terminal. You can close it for now.

Share

2. What Genuinely Changes

Once you're set up, most things feel familiar. Here's what actually surprised me.

Your Web Connectors Just Work

Whatever you connected in Cowork — Gmail, Slack, Notion — works here too. No reconfiguration. They're tied to your Anthropic account, not to the app. To see them, use the "/" menu:

Auto Memory Replaces Our Workaround

Remember how we set up cross-session memory in Cowork with Desktop Commander? That was a workaround.

Code has Auto Memory built in (it was just released). Claude automatically saves patterns, preferences, and decisions to a MEMORY.md file per workspace. It persists across sessions — no setup needed.

You can manage it with /memory and ask Claude to remember or forget specific things.

The progression:

• Chat has memory per Projects

• We set it up manually in Cowork

• Code has the easiest version

Plan Mode — Think Before You Act

Hit Shift+Tab and Claude switches to Plan Mode. It analyzes your request, proposes an approach, and waits for approval before touching anything.

For PMs, this is how you explore a codebase safely. This is similar to what you may know from Lovable.

Message Queuing — Stack Requests

You can type your next request while Claude is still working on the current one. It queues them and works through them in order.

Sounds small. In practice, it means you can dump a sequence of tasks — “fix the header, then update the copy on the pricing page, then run the tests” — and walk away (Lovable has it, too).

Context Window — You Can See It Now

Claude Code extension shows your context usage when you’re above 50%:

Type /context to visualize it:

The same method works in Claude Code CLI:

This matters because Claude's thinking quality degrades as the context fills up. When it climbs past 50%, use /compact to compress the conversation. In Cowork, you're flying blind on this.

Effort Control

In Chat, you toggle extended thinking on and off. In Cowork, it's adaptive. In Code, it's adaptive by default — but you get direct control via /effort. Higher for complex analysis, lower for quick edits:

File References with @

Type @ to reference any file from your workspace. Genuinely better than in Cowork for engineering workflows — you get autocomplete across the entire project:

3. Claude Code - Three Extra Tips

Explorer View — Your Project Structure, Always Visible

Cowork can also work with files in a folder (especially with Desktop Commander). But in Code, the project structure is always visible in the sidebar — and Claude can efficiently search across it with built-in tools:

The difference isn’t “can it read files” — both can. It’s that Code makes your project structure a first-class citizen.

For knowledge work, I find Cowork's in-context file panel more natural:

But when you're working with a codebase, there are moments the built-in explorer isn't enough and you need a full hierarchical view.

How to Visualize and Edit .md Files

I recommend you install "Markdown Preview Enhanced" extension. After clicking Cmd+Shift+V or Ctrl+Shift+V you're able to use the WYSIWYG editor:

If you right click an .md file → Open With…, you can make this a default behavior:

How to Connect to More Apps without Local MCPs

Claude Desktop offers built-in MCP Servers ("web connectors") for many popular apps (Gmail, Notion, Figma, Slack, etc.). Once configured, they are available in Claude Code, too.

To add more, you can use Pipedream MCP (a free platform) to connect to 1,000s of APIs and apps with a single MCP server:

• Step 1: Go to https://mcp.pipedream.com/

• Step 2: Connect your apps.

• Step 3: In Claude Desktop, add a single custom web connector and follow the instructions: https://mcp.pipedream.net/v2

It works across the entire Claude ecosystem — Chat, Cowork, Code Tab, Claude Code (CLI and VS Code extension).

Share

Next, we continue with:

• PM Power Moves

• Honest Caveats — Where Cowork Is Still Better

• Going Further — When You're Ready

• What’s Next

4. PM Power Moves

Read more

Here’s what you might have recently missed:

1. Claude Cowork: The Ultimate Guide for PMs

2. How I Built a Secure Autonomous AI Agent with Claude and n8n

3. How to Build an AI Agent with n8n and Lovable (No Coding)

4. Your Complete Roadmap to Earning a $180K–$569K AI PM Role

5. How to Build, Deploy, And Scale Your AI Product Strategy From Scratch

Consider subscribing and upgrading your account for the full experience.

Subscribe now

I’ve just launched the PM Skills Marketplace on GitHub.

65 PM skills and 36 chained workflows across 8 Claude plugins based on proven frameworks. It’s open source and available to everyone.

Designed for Claude Code and Cowork. Skills compatible with other AI assistants.

1. Why PM Skills Marketplace?

Generic AI gives you text. PM Skills Marketplace gives you structure.

Each skill encodes a proven PM framework — discovery, assumption mapping, prioritization, strategy — and walks you through it step by step. You get the rigor of Teresa Torres, Marty Cagan, and Alberto Savoia built into your daily workflow, not sitting on a bookshelf.

The result: better product decisions, not just faster documents.

2. How It Works (Skills, Commands, Plugins)

Skills are the building blocks of the marketplace. Each skill gives Claude domain knowledge, analytical frameworks, or a guided workflow for a specific PM task. Some skills also work as reusable foundations that multiple commands share.

Skills are loaded automatically when relevant to the conversation — no explicit invocation needed. If needed (e.g., prioritizing skills over general knowledge), you can force loading skills with /plugin-name:skill-name or /skill-name (Claude will add the prefix).

Commands are user-triggered workflows invoked with /command-name. They chain one or more skills into an end-to-end process. For example, /discover chains four skills together: brainstorm-ideas → identify-assumptions → prioritize-assumptions → brainstorm-experiments.

Plugins group related skills and commands into installable packages. Each plugin covers a PM domain — discovery, strategy, execution, and so on. Installing the marketplace gives you all 8 plugins at once.

Commands use skills. Some skills serve multiple commands. Some skills (like prioritization-frameworks or opportunity-solution-tree) are standalone references that Claude draws on whenever relevant — no command needed.

Commands are designed to flow into each other, matching the PM workflow. After any command completes, it suggests relevant next commands — just follow the prompts.

If this project helps you, ⭐ the repo on GitHub.

Share

3. Installation

3.1 Claude Cowork (recommended for non-developers)

1. Open Customize (bottom-left)

2. Go to Browse plugins → Personal → +

3. Select Add marketplace from GitHub

4. Enter: phuryn/pm-skills

All 8 plugins install automatically. You get both commands (/discover, /strategy, etc.) and skills.

For more information, see Claude Cowork: The Ultimate Guide for PMs.

3.2 Claude Code (CLI)

# Step 1: Add the marketplace
claude plugin marketplace add phuryn/pm-skills

# Step 2: Install individual plugins
claude plugin install pm-toolkit@pm-skills
claude plugin install pm-product-strategy@pm-skills
claude plugin install pm-product-discovery@pm-skills 
claude plugin install pm-market-research@pm-skills 
claude plugin install pm-data-analytics@pm-skills
claude plugin install pm-marketing-growth@pm-skills
claude plugin install pm-go-to-market@pm-skills
claude plugin install pm-execution@pm-skills

3.3 Other AI assistants (skills only)

The skills/*/SKILL.md files follow the universal skill format and work with any tool that reads it. Commands (/slash-commands) are Claude-specific.

# Example: copy all skills for Gemini CLI
for plugin in pm-*/; do
  cp -r “$plugin/skills/”* ~/.gemini/skills/ 2>/dev/null
done

4. Available Plugins

4.1. pm-product-discovery

Continuous product discovery: ideation, experiments, assumption testing, feature prioritization, Opportunity Solution Trees, and customer interviews.

Skills (13):

• brainstorm-ideas-existing — Multi-perspective ideation for existing products (PM, Designer, Engineer)

• brainstorm-ideas-new — Ideation for new products in initial discovery

• brainstorm-experiments-existing — Design experiments to test assumptions for existing products

• brainstorm-experiments-new — Design lean startup pretotypes for new products (Alberto Savoia)

• identify-assumptions-existing — Identify risky assumptions across Value, Usability, Viability, and Feasibility

• identify-assumptions-new — Identify risky assumptions across 8 risk categories including Go-to-Market, Strategy, and Team

• prioritize-assumptions — Prioritize assumptions using an Impact × Risk matrix with experiment suggestions

• prioritize-features — Prioritize a feature backlog based on impact, effort, risk, and strategic alignment

• analyze-feature-requests — Analyze and categorize customer feature requests by theme and strategic fit

• opportunity-solution-tree — Build an Opportunity Solution Tree (Teresa Torres) — outcome → opportunities → solutions → experiments

• interview-script — Create a structured customer interview script with JTBD probing questions

• summarize-interview — Summarize an interview transcript into JTBD, satisfaction signals, and action items

• metrics-dashboard — Design a product metrics dashboard with North Star, input metrics, and alert thresholds

Commands (5):

• /discover — Full discovery cycle: ideation → assumption mapping → prioritization → experiment design

• /brainstorm — Multi-perspective ideation (ideas|experiments × existing|new)

• /triage-requests — Analyze and prioritize a batch of feature requests

• /interview — Prepare an interview script or summarize a transcript (prep|summarize)

• /setup-metrics — Design a product metrics dashboard

Examples:

Skills:

• What are the riskiest assumptions for our AI writing assistant idea?

• Help me build an Opportunity Solution Tree for improving user activation

• Prioritize these 12 feature requests from our enterprise customers [attach CSV]

Commands:

• /discover AI-powered meeting summarizer for remote teams

• /brainstorm experiments existing — We need to reduce churn in our onboarding flow

• /interview prep — We're interviewing enterprise buyers about their procurement workflow

4.2. pm-product-strategy

Product strategy, vision, business models, pricing, and macro environment analysis. Covers the full strategic toolkit from vision crafting through competitive landscape scanning.

Skills (12):

• product-strategy — Comprehensive 9-section Product Strategy Canvas (vision → defensibility)

• startup-canvas — Startup Canvas combining Product Strategy (9 sections) + Business Model — an alternative to BMC and Lean Canvas for new products

• product-vision — Craft an inspiring, achievable, and emotional product vision

• value-proposition — 6-part JTBD value proposition (Who, Why, What before, How, What after, Alternatives)

• lean-canvas — Lean Canvas business model for startups and new products

• business-model — Business Model Canvas with all 9 building blocks

• monetization-strategy — Brainstorm 3–5 monetization strategies with validation experiments

• pricing-strategy — Pricing models, competitive analysis, willingness-to-pay, and price elasticity

• swot-analysis — SWOT analysis with actionable recommendations

• pestle-analysis — Macro environment: Political, Economic, Social, Technological, Legal, Environmental

• porters-five-forces — Competitive forces analysis (rivalry, suppliers, buyers, substitutes, new entrants)

• ansoff-matrix — Growth strategy mapping across markets and products

Commands (5):

• /strategy — Create a complete 9-section Product Strategy Canvas

• /business-model — Explore business models (lean|full|startup|value-prop|all)

• /value-proposition — Design a value proposition using the 6-part JTBD template

• /market-scan — Macro environment analysis combining SWOT + PESTLE + Porter’s + Ansoff

• /pricing — Design a pricing strategy with competitive analysis and experiments

Examples:

Skills:

• Compare Lean Canvas vs Business Model Canvas vs Startup Canvas for my marketplace startup

• Design a value proposition for our AI writing assistant targeting non-native English speakers

• Run a Porter's Five Forces analysis for the project management SaaS market

Commands:

• /strategy B2B project management tool for agencies

• /business-model startup — AI writing tool for non-native English speakers

• /value-proposition SaaS onboarding tool for enterprise customers

4.3. pm-execution

Day-to-day product management: PRDs, OKRs, roadmaps, sprints, retrospectives, release notes, pre-mortems, stakeholder management, user stories, and prioritization frameworks.

Skills (15):

• create-prd — Comprehensive 8-section PRD template

• brainstorm-okrs — Team-level OKRs aligned with company objectives

• outcome-roadmap — Transform a feature list into an outcome-focused roadmap

• sprint-plan — Sprint planning with capacity estimation, story selection, and risk identification

• retro — Structured sprint retrospective facilitation

• release-notes — User-facing release notes from tickets, PRDs, or changelogs

• pre-mortem — Risk analysis with Tigers/Paper Tigers/Elephants classification

• stakeholder-map — Power × Interest grid with tailored communication plan

• summarize-meeting — Meeting transcript → decisions + action items

• user-stories — User stories following the 3 C’s and INVEST criteria

• job-stories — Job stories: When [situation], I want to [motivation], so I can [outcome]

• wwas — Product backlog items in Why-What-Acceptance format

• test-scenarios — Test scenarios: happy paths, edge cases, error handling

• dummy-dataset — Realistic dummy datasets as CSV, JSON, SQL, or Python

• prioritization-frameworks — Reference guide to 9 prioritization frameworks (Opportunity Score, ICE, RICE, MoSCoW, Kano, etc.)

Commands (10):

• /write-prd — Create a PRD from a feature idea or problem statement

• /plan-okrs — Brainstorm team-level OKRs

• /transform-roadmap — Convert a feature-based roadmap into outcome-focused

• /sprint — Sprint lifecycle (plan|retro|release)

• /pre-mortem — Pre-mortem risk analysis on a PRD or launch plan

• /meeting-notes — Summarize a meeting transcript into structured notes

• /stakeholder-map — Map stakeholders and create a communication plan

• /write-stories — Break features into backlog items (user|job|wwa)

• /test-scenarios — Generate test scenarios from user stories

• /generate-data — Create realistic dummy datasets

Examples:

Skills:

• Which prioritization framework should I use for a 50-item backlog?

• Map our stakeholders for the platform migration project

• What's the difference between Opportunity Score, ICE, and RICE?

Commands:

• /write-prd Smart notification system that reduces alert fatigue

• /sprint retro — Here are the notes from our last sprint

• /write-stories job — Break down the "team dashboard" feature into job stories

4.4. pm-market-research

User research and competitive analysis: personas, segmentation, journey maps, market sizing, competitor analysis, and feedback analysis.

Skills (7):

• user-personas — Create refined user personas from research data

• market-segments — Identify 3–5 customer segments with demographics, JTBD, and product fit

• user-segmentation — Segment users from feedback data based on behavior, JTBD, and needs

• customer-journey-map — End-to-end journey map with stages, touchpoints, emotions, and pain points

• market-sizing — TAM, SAM, SOM with top-down and bottom-up approaches

• competitor-analysis — Competitor strengths, weaknesses, and differentiation opportunities

• sentiment-analysis — Sentiment analysis and theme extraction from user feedback

Commands (3):

• /research-users — Build personas, segment users, and map the customer journey

• /competitive-analysis — Analyze the competitive landscape

• /analyze-feedback — Sentiment analysis and segment insights from user feedback

Examples:

Skills:

• Estimate TAM/SAM/SOM for an AI code review tool in the US market

• Create a customer journey map for our e-commerce checkout flow

• Segment these survey respondents by behavior and needs [attach CSV]

Commands:

• /research-users We have interview data from 12 users of our fitness app

• /competitive-analysis Figma competitors in the design tool space

• /analyze-feedback Here's 200 NPS responses from Q4 [attach file]

4.5. pm-data-analytics

Data analytics for PMs: SQL query generation, cohort analysis, and A/B test analysis.

Skills (3):

• sql-queries — Generate SQL from natural language (BigQuery, PostgreSQL, MySQL)

• cohort-analysis — Retention curves, feature adoption, and engagement trends by cohort

• ab-test-analysis — Statistical significance, sample size validation, and ship/extend/stop recommendations

Commands (3):

• /write-query — Generate SQL queries from natural language

• /analyze-cohorts — Cohort analysis on user engagement data

• /analyze-test — Analyze A/B test results

Examples:

Skills:

• How large a sample do I need for 95% confidence with a 2% MDE?

• What retention metrics should I track for a subscription app?

Commands:

• /write-query Show me monthly active users by country for Q4 2025 (BigQuery)

• /analyze-test Here are the results from our checkout flow A/B test [attach CSV]

• /analyze-cohorts Weekly retention for users who signed up in January vs February

4.6. pm-go-to-market

Go-to-market strategy: beachhead segments, ideal customer profiles, messaging, growth loops, GTM motions, and competitive battlecards.

Skills (6):

• gtm-strategy — Full GTM strategy: channels, messaging, success metrics, and launch plan

• beachhead-segment — Identify the first beachhead market segment

• ideal-customer-profile — ICP with demographics, behaviors, JTBD, and needs

• growth-loops — Design sustainable growth loops (flywheels)

• gtm-motions — Evaluate GTM motions and tools (product-led, sales-led, etc.)

• competitive-battlecard — Sales-ready battlecard with objection handling and win strategies

Commands (3):

• /plan-launch — Full GTM strategy from beachhead to launch plan

• /growth-strategy — Design growth loops and evaluate GTM motions

• /battlecard — Create a competitive battlecard

Examples:

Skills:

• What's the best beachhead segment for a developer productivity tool?

• Design a growth loop for a B2B SaaS with a freemium tier

• Define our ICP for an AI-powered HR screening platform

Commands:

• /plan-launch AI code review tool targeting mid-size engineering teams

• /battlecard Our CRM vs Salesforce for the SMB market

• /growth-strategy Two-sided marketplace for connecting freelancers with startups

4.7. pm-marketing-growth

Product marketing and growth: marketing ideas, positioning, value proposition statements, product naming, and North Star metrics.

Skills (5):

• marketing-ideas — Creative, cost-effective marketing ideas with channels and messaging

• positioning-ideas — Product positioning differentiated from competitors

• value-prop-statements — Value proposition statements for marketing, sales, and onboarding

• product-name — Product name brainstorming aligned to brand values and audience

• north-star-metric — North Star Metric + input metrics with business game classification

Commands (2):

• /market-product — Brainstorm marketing ideas, positioning, value props, and product names

• /north-star — Define your North Star Metric and supporting input metrics

Examples:

Skills:

• Brainstorm 5 positioning angles that differentiate us from Notion

• What's a good North Star Metric for a two-sided marketplace?

• Generate value prop statements for our sales team's pitch deck

Commands:

• /market-product B2B analytics dashboard for e-commerce managers

• /north-star Two-sided marketplace connecting freelancers with clients

4.8. pm-toolkit

PM utilities beyond core product work: resume review, legal documents, and proofreading.

Skills (4):

• review-resume — PM resume review and tailoring against 10 best practices (XYZ+S formula, keywords, structure)

• draft-nda — Non-Disclosure Agreement with jurisdiction-appropriate clauses

• privacy-policy — Privacy policy covering GDPR/CCPA compliance

• grammar-check — Grammar, logic, and flow checking with targeted fixes

Commands (5):

• /review-resume — Comprehensive PM resume review

• /tailor-resume — Tailor a resume to a specific job description

• /draft-nda — Draft an NDA

• /privacy-policy — Draft a privacy policy

• /proofread — Check grammar, logic, and flow

Examples:

Skills:

• Review my PM resume against best practices [attach PDF]

• Check this product announcement for grammar and clarity

Commands:

• /review-resume [attach your PM resume]

• /tailor-resume [attach resume + paste job description]

• /proofread Here's the draft of our Q1 investor update

Share

About

This marketplace evolves with product practice and AI capabilities.

Selected skills based on the work of:

• Teresa Torres — Continuous Discovery Habits

• Marty Cagan — INSPIRED and TRANSFORMED

• Alberto Savoia — The Right It

• Dan Olsen — The Lean Product Playbook

• Roger L. Martin — Playing to Win

• Ash Maurya — Running Lean

• Strategyzer — Business Model Generation and Value Proposition Design

• Christina Wodtke — Radical Focus

• Anthony W. Ulwick — Jobs to Be Done

• Alistair Croll & Benjamin Yoskovitz — Lean Analytics

• Sean Ellis — Hacking Growth

• Maja Voje — Go-To-Market Strategist

Curated by The Product Compass Newsletter by Paweł Huryn.

Thanks for Reading The Product Compass

If this project helps you, ⭐ the repo on GitHub!

It’s amazing to learn and grow together.

We will continue with Claude Code. Consider subscribing and upgrading your account to access all resources. It’s easily a 50x ROI.

Subscribe now

Have a great week ahead,
Paweł

Here’s what you might have recently missed:

1. How I Built a Secure Autonomous AI Agent with Claude and n8n

2. How to Build an AI Agent with n8n and Lovable (No Coding)

3. The Intent Engineering Framework for AI Agents

4. Your Complete Roadmap to Earning a $180K–$569K AI PM Role

5. How to Build, Deploy, And Scale Your AI Product Strategy From Scratch

Consider subscribing and upgrading your account for the full experience.

Subscribe now

Note: Anthropic dropped important changes just after the publication.

This article was updated:

• March 7, 2026 — Anthropic released /loop for Claude Code, refreshed infographics

• March 6, 2026 — Anthropic released auto memory for Claude Code (point 7), refreshed infographics

• February 26, 2026 — Cowork now supports scheduled tasks (point 5)

• February 25, 2026 — Anthropic reorganized the left menu (points 2-4)

Anthropic just shipped Claude Cowork for Windows and Intel-based macOS with full feature parity to the version released in January. It’s now available on all platforms for Pro, Max, Team, and Enterprise plans.

Everyone’s hyping Claude Code. But if you’re not a developer, Cowork might be a better default option for everyday tasks — and almost nobody’s talking about it enough.

I'm a former engineer. I can use the terminal just fine. But prototyping aside, I choose Cowork for day-to-day work: analyzing and drafting emails, reorganizing files, preparing contracts, managing invoices, and even configuring my OS.

Same model as Claude Code. Same skill format, same connector types.

Technically, Code can do everything Cowork does. The difference is how you get there. Code needs git worktrees, tmux, and CLI flags. Cowork gives you a simple visual interface.

This guide covers everything you need to know:

1. What Cowork Actually Is

2. Cowork vs. Chat: Why it’s a Different Beast

3. Plugins, Commands, and Skills in Claude Cowork

4. MCPs: Connecting Cowork to Your World

5. Scheduled Tasks

6. A 1-Minute Hack That Makes Claude Desktop 2x More Powerful

7. How to Give Claude Cowork Cross-Session Memory

1. What Cowork Actually Is

Cowork is not a chat interface with a new skin. It’s an autonomous desktop agent built into the Claude Desktop app.

When you open the Cowork tab, you’re giving Claude access to a sandboxed Linux VM running on your machine. Inside that sandbox, Claude can write code, execute scripts, create files (Word docs, slide decks, spreadsheets, PDFs), and connect to services like Gmail, GitHub, and Slack (you don't set this up — Anthropic manages it).

You describe what you need. Cowork plans the work, breaks it into sub-agents that run in parallel, and delivers output as clickable files you can open directly.

A few things that set it apart from Chat:

• It plans and tracks work. Give Cowork a complex task and it decomposes it into subtasks, shows you the plan, and works through it step by step. You can watch progress in real time and steer mid-task. Chat doesn’t do this.

• It coordinates parallel work. Cowork can spawn sub-agents — independent Claude instances that each get their own context — to work on different parts of a task simultaneously.

• It creates real files. Not an artifact. Actual .docx, .pptx, .xlsx, and .pdf files delivered to the folder you granted access to.

• It’s sandboxed — but not entirely. Cowork runs in a VM, so it can’t touch your OS or files outside the folder you shared. But inside that folder, it has full read/write/delete access.

• It connects to your tools. Gmail, GitHub, Slack, Google Drive, and more via built-in connectors. Plus any custom tool via MCP servers.

2. Cowork vs. Chat: Why it’s a Different Beast

Many of you already use Claude Chat in the Desktop app. You might be wondering: what does Cowork add? Here’s my comparison:

In short, Cowork adds what matters for getting real work done: sub-agent coordination that handles parallel work, task decomposition, and files delivered directly to your folder instead of chat artifacts.

Chat is for conversations. Cowork is for workflows.

3. Plugins, Commands, and Skills in Claude Cowork

When Anthropic unveiled AI tools automating legal and financial research in early 2026, legacy software stocks dropped $285 billion in a single day. Investors saw AI agents moving into the application layer — legal, sales, marketing, finance — and repriced the entire software sector.

The plugins sitting in your Cowork sidebar are part of what triggered that reaction. Here’s how they work.

What are skills?

Let’s start with skills. They are reusable instruction manuals that teach Claude how to approach specific, repeatable tasks. Say “create a Word doc” and the docx skill loads.

The format works across Claude ecosystem and third-party tools like Cursor, Windsurf, and Codex CLI.

Built-in skills include pdf, docx, pptx, xlsx, canvas-design, algorithmic-art, and skill-creator.

Skills don’t all load at once. Claude reads only a short description of each skill (~100 tokens) to decide which ones are relevant, then loads full instructions only when needed. This keeps your context window clean.

What are commands?

Commands are structured workflows you trigger by typing a slash command. Type /strategy and Claude walks you through a full product strategy canvas — gathering context, applying the right frameworks, and producing formatted output.

Commands can chain together skills: /strategy → /business-model → /pricing → /plan-launch follows the natural PM workflow from vision to execution.

The Cowork plugin panel

Cowork has a dedicated Plugins panel. You can browse, install, upload, and create plugins from a visual UI:

Each plugin bundles skills with slash commands, for example “Product Management:”

Skills are auto-discovered, but you can also plugins and commands with slash commands:

Skill and plugin access across tools

Here’s the high-level picture. In this article we focus on Cowork:

Default plugins:

• Cowork ships with 11 plugins from anthropics/knowledge-work-plugins (productivity, product-management, legal, finance, marketing, data, etc.)

• Code’s marketplace defaults to anthropics/claude-code (developer workflows: agent-sdk-dev, frontend-desing, feature-dev, code-review, etc.).

But you can add any marketplace repo to either tool — load Code’s developer plugins into Cowork, or Cowork’s business plugins into Code. Same skill format, fully cross-compatible.

Note: Cowork and Code Tab have separate, isolated plugin panels. Installing a plugin in one doesn't make it available in the other. Skills uploaded via Claude Desktop settings are shared across Chat, Cowork, and Code Tab.

Where to find more skills and plugins

Beyond built-in skills and Anthropic’s plugins, there’s a growing ecosystem worth exploring. All essential sources:

1. github.com/phuryn/pm-skills: PM Skills Marketplace — 100+ agentic skills, commands, and plugins — from discovery to strategy, execution, launch, and growth

2. github.com/anthropics/skills: Anthropic’s official repo — document skills (docx, xlsx, pptx, pdf) plus creative, technical, and enterprise examples

3. github.com/anthropics/knowledge-work-plugins: Cowork’s default plugin registry — the 11 business-role plugins

4. github.com/anthropics/claude-code: Developer-focused workflows — Code's default marketplace source, open “Plugins”

5. claudemarketplaces.com: Browse and discover plugin marketplaces you can add to Cowork or Code

6. github.com/travisvn/awesome-claude-skills: Community-curated collection with battle-tested skills for TDD, debugging, collaboration

7. github.com/sickn33/antigravity-awesome-skills: 868+ universal agentic skills — covers security, DevOps, full-stack, AI/ML, and more. Role-based bundles (Startup Founder, Marketing & Growth, etc.) let you pick what’s relevant. Works with Claude Desktop, Claude Code, Cursor, Gemini CLI, Codex, OpenCode, and Antigravity

8. skills.sh: Vercel’s open skills ecosystem — directory and leaderboard, CLI installer (npx skills add). PM-relevant skills include product strategy frameworks, pricing strategy, launch playbooks, discovery interview guides, PRD generator, analytics tracking setup, resume optimizer, and more. Full repo also covers marketing, SEO, copywriting, and web design. Works with 18+ agents

9. skillsmp.com: Community marketplace — 200K+ skills indexed from GitHub, searchable by category

10. skillhub.club: 7,000+ AI-evaluated skills with quality scores, one-click install via desktop app

11. agentskills.io: The open format specification — if you want to build your own

Share

4. MCPs: Connecting Cowork to Your World

MCP stands for Model Context Protocol — the open standard by Anthropic. Each MCP server exposes tools Claude can call.

A custom Gmail MCP gives Claude search_emails, send_email, read_email. The official official GitHub MCP gives it create_pull_request, list_issues. You get the idea.

There are three ways to connect MCP servers to Claude, and understanding the difference matters. When I say “Claude Desktop” below, I mean all three tabs in the Desktop app: Chat, Cowork, and Code.

Three types of MCP connections

Web connectors work everywhere — including claude.ai in your browser. Those can be built-in (delivered by Anthropic) or custom (HTTP Streamable + OAuth) MCPs. You manage them in “Customize> Connectors”:

Desktop connectors are how Anthropic packages local MCP servers for one-click install — they show up in both the Extensions panel (to install/remove) and the Connectors panel (to toggle on/off). You manage them in “Settings > Extensions”:

Custom MCP servers are managed by editing a JSON config. Click “Menu > Developer > App Config File…” An example content with a custom Gmail and Outlook MCPs (Edited: I needed the first one when publishing this post, drafting and sending emails is not supported by the built-in connector):

{
  "mcpServers": {
    "gmail": {
      "command": "npx",
      "args": [
        "@gongrzhe/server-gmail-autoauth-mcp"
      ]
    },
    "outlook-assistant": {
      "command": "C:\\nvm4w\\nodejs\\node.exe",
      "args": [
        "C:\\Users\\Dell\\outlook-mcp\\index.js"
      ],
      "env": {
        "USE_TEST_MODE": "false",
        "OUTLOOK_CLIENT_ID": "6c****-**************",
        "OUTLOOK_CLIENT_SECRET": "53**************_**************"
      }
    }
  }
}

What might be a bit confusing is that Claude Desktop presents them all in a single “Connectors” interface with on/off toggles:

Per-tool permissions

For every connector, you can set individual tools to Allow (runs automatically), Ask (confirms before running), or Block (never runs). You could allow Claude to search your emails but block it from sending them. Click: “Customize→ Connectors → Tool permissions”:

MCP config is not shared across all tools

Different tools use different config methods. For example, adding an MCP server to Chat makes it available in Cowork, and Code Tab, but not Claude Code (CLI & VS Code Extension):

Windows gotcha: If you installed Claude Desktop via the Microsoft Store (MSIX), the "Edit Config" button may open the wrong file. The app reads from the MSIX virtualized path, not %APPDATA%\Claude\. Check GitHub issue #26073 if MCP servers silently fail to load.

Where to find MCP servers

1. github.com/modelcontextprotocol/servers: Official MCP server repo — filesystem, GitHub, Google Drive, Slack, and more

2. modelcontextprotocol.io/examples: Official MCP directory — reference implementations for many services

3. github.com/punkpeye/awesome-mcp-servers: Community-curated list — hundreds of MCP servers by category

4. mcp.so: MCP server registry with search and install instructions

Share

Thanks for reading so far. Continue with:

• Scheduled Tasks: Best Practices (Save a Few Hours / Week)

• A 1-Minute Hack That Makes Claude Desktop 2x More Powerful

• How to Give Claude Cowork Cross-Session Memory

• Detailed visual assets across the Claude ecosystem 👇

5. Scheduled Tasks: Best Practices

Read more

That’s what happened during our AI Agents Buildathon — and the quality blew us away.

Teams didn’t just build MVPs. They crafted sharp value propositions, justified differentiation, planned defensible moats, and designed guardrails and autonomy boundaries for their AI agents.

The gallery is free to access here:

Open AI Solutions Gallery

To every team that shared their work publicly — you did what 99% of PMs only talk about. You went from idea to working product in weeks. We’re proud of what you built 🚀😊

Vote and Win $2,000

You can browse the gallery, explore the solutions, and upvote your favorites. On March 1, 2026, I’ll randomly select one voter who wins $2,000 and 10 voters who get a 1-year subscription.

[Edited] You can see the winners at the end of this article.

Beyond the prize, the gallery is worth your time. You can study how teams approached their implementations, tradeoffs they made, real-world challenges and what they learned. It’s one of the best ways to learn agent design.

Open AI Solutions Gallery

Thank You

Special thanks to , the mind behind this program. Olia spent days connecting with teams, solving technical issues, and automating our workflows with AI agents. I couldn't have done it without you.

Thanks also to Lovable for supporting our program with free credits for participants.

And to every participant — whether you shipped publicly or not — thank you for building with us. Almost 100 AI PRD submissions came through. That’s a community that takes building seriously 💪

Resources to Get You Started

Key materials studied participants. No coding required:

1. How to Build a RAG Chatbot
   The best way to quickly understand n8n

2. How to Build an AI Agent with n8n and Lovable
   The core process most participants wen through

3. The Ultimate Guide to n8n for PMs
   Best n8n practices and how to plan for autonomy

4. A Guide to Context Engineering for PMs
   When building agents, context is everything

5. The Intent Engineering Framework for AI Agents
   How to set context, choose the right autonomy level, and design hard constraints - critical for setting autonomy boundaries

6. A PM’s Guide to Evaluating AI Agents
   Everything you need to know to start working with AI evals

7. Build, Deploy, And Scale Your AI Product Strategy
   The paradigm shift: differentiation, sustainable moat, costs, and distribution

Next Buildathon: Q2 2026

Starting next edition, the Buildathon will have a separate fee. If you subscribe to The Product Compass premium now, you'll get access to the Q2 2026 Buildathon at no extra cost — last chance before pricing changes.

Subscribe now

Edited: Voting Contest Winners

Thanks for Reading The Product Compass Newsletter

Thanks for learning and growing together!

Two guides coming next that will radically simplify your work as a PM.

Start building. Stop theorizing.

Have a great week ahead, Paweł

(Boosting SEO and agentic search for participants)

Top solutions include:

• Agent Trust Gate — AI-Powered Product Data Validation for Marketplaces

• Hunter-spark — The AI Sales Agent That Finds B2B Prospects at the Moment They’re Ready to Buy

I wanted that. But I didn't want OpenClaw

As I warned last week, OpenClaw gives an AI agent full access to your environment. Your files, your terminal, your API keys — everything. The "guardrails" are prompt instructions. Any injected prompt can override them.

The results:

• 35,000 emails and 1.5M API keys exposed.

• The top-downloaded community skill? Malware.

So, I built Agent One — autonomous capabilities, hard security boundaries, no code required.

And yes — I built it as a PM, not an engineer.

Building as a PM is essential. You don't need to code. But you need to develop AI intuition and AI product sense. It's not about mastering specific tools — most will be obsolete in months. It's about building mental models and transferable skills that compound.

In this post:

1. What Agent One Actually Does

2. The Architecture in Plain English

3. The “Ralph Wiggum” Loop

4. 9 Lessons From Building My OpenClaw Alternative

5. Complete Setup Guide with Templates

Subscribe now

1. What Agent One Actually Does

Agent One is a personal AI assistant that runs on a $4.99/month VPS. You talk to it through Telegram. It already can:

• Research topics and generate PDF reports

• Draft and send emails on your behalf

• Create and update Google Sheets, Docs

• Read and process files from your laptop

• Install tools it needs, remember what it learned, and get better over time

But unlike OpenClaw, Agent One can’t:

• Access your API keys (they live in n8n, not in the agent’s environment)

• Modify its own environment or guardrails

• Access folders you haven’t explicitly shared

• Use tools you haven’t approved

• Send emails without your confirmation

These aren’t prompt instructions. They’re hard architectural boundaries — Docker isolation, mounted folder permissions, n8n’s tool approval system.

Share

2. The Architecture in Plain English

Here’s the architecture:

The VPS on Hostinger hosts n8n and sandbox containers. The sandbox is available only from n8n - this is where VPS Executor agent can manage files, install new tools, and execute scripts.

The Manager is the brain. It plans, decides, delegates, and talks to the user. It never touches files. It never runs scripts. It works entirely from executor summaries.

The Executors are the hands. Each receives a task (what to do + why it matters), decides how to execute it, and reports back. They're autonomous — the Manager doesn't prescribe steps. Two types:

• VPS Executor has access to a sandbox container via Desktop Commander MCP (files + shell)

• (Optional) Laptop Executor connects to your local environment (ideally Docker on your laptop) via a secure Cloudflare Tunnel + mcp-proxy + Desktop Commander MCP — no public IP or static address needed.

Data Tables in n8n store both memories and sessions — no external database, no vector store, no infrastructure. Just rows in a table.

Memory is the long-term knowledge. Two types:

• Manager memory: user preferences, facts, corrections, project context

• Executor environment memory: what tools are installed, what’s broken, workarounds discovered

Sessions are short-term state for multi-step tasks. Original request, plan, assumptions, and a log. When the Manager loops with fresh context, the session is all it gets.

3. The “Ralph Wiggum” Loop

For complex multi-step tasks, Agent One uses my variant of the Ralph Wiggum loop.

When the Manager outputs Continue, the orchestrator resets its context completely. The next iteration has no memory of what just happened — except the session.

The session is everything. Original request, goal, plan with statuses, assumptions, log. The orchestrator loads it and injects it as the Manager’s context.

This is deliberate. Long chains of actions accumulate noise — large executor outputs, tool call artifacts, outdated reasoning. A clean session beats a cluttered full history.

Simple tasks don’t need this — the Manager calls one executor, gets the result, responds Done. Complex tasks (research → generate report → upload → email) use sessions with Continue to keep each phase clean.

Share

4. 9 Lessons From Building My OpenClaw Alternative

These apply to any multi-agent system, not just n8n.

4.1 Manage through context, not scripts

Initially, I had the Manager telling Executors exactly what to do: “Step 1: install pandoc. Step 2: create markdown file. Step 3: convert to PDF. Step 4: upload to Drive.”

This fails. The moment something unexpected happens (pandoc isn’t available, the conversion produces bad output), the Executor has no idea what to do — it was following a script, not understanding a goal.

The fix: give the Executor three things — context (why this matters), goal (what must be true), and constraints (what must not happen). Let it figure out the how.

The Executor went from a script runner that broke on every edge case to an autonomous agent that adapts and recovers.

From the System Prompt:

“The executor is an autonomous agent, not a script runner. Give it enough context to make smart decisions (…) Do not prescribe steps, enumerate specific tools, or decompose into sub-phases. The executor decides how.”

We discussed that approach also in The Intent Engineering Framework for AI Agents.

4.2 Implement hard guardrails vs. soft suggestions

‘Ask me before sending an email’ as a prompt instruction = a suggestion. The model ignores it under pressure.

Wrapping it in an orchestrated gateway = a hard guardrail. The model can’t skip it:

Two other examples:

This is exactly what went wrong with OpenClaw. Its security model was prompt instructions ("don't access sensitive files"), not architectural boundaries. A prompt injection overrides them anytime.

Autonomy without constraints is a liability.

4.3 Minimal contract for multi-agent coordination

The Manager–Executor interface is 3 fields: context, goal, constraints.

I tried adding more:

• executor_tasks (array of sub-tasks),

• internal_notes (reasoning for next iteration),

• env_context (what tools are installed).

Each addition made the system worse. The model spent more tokens managing the contract than doing the work.

Keep contracts minimal.

Structured outputs are essential for the orchestration layer — but agents aren't algorithms. They don't need perfectly formatted inputs.

4.4 Separation of concerns

The Manager cannot write files. Cannot run scripts. Cannot read file contents. It works from executor summaries only.

This felt like an artificial limitation until I removed it. The moment the Manager could touch files, it started doing executor work — running shell commands, creating documents mid-conversation, bypassing the executor entirely. The clean separation broke down, and with it, the session state, the memory system, and the error handling.

Same principle: executors own their environment memory. The Manager doesn't know exactly what's installed on the VPS — and shouldn't. Each layer manages its own knowledge.

4.5 Best frontier models still need human judgment

I used Claude Opus 4.6 (with extended thinking) and GPT-5.3 to help design this system. Both are impressive. Both failed to catch inconsistencies between tool descriptions and prompt instructions. Both wrote prompts that contradicted their own earlier decisions. Both needed me to spot the bugs.

AI accelerates architecture work enormously. But if you hand off system design entirely — even to the best models — you get subtle cracks that only show up at runtime.

4.6 The prompt is version-controlled code

In the early version, my prompts lived in GitHub. Every change was a commit. This isn't optional for production systems.

In the current version, I imported stable prompts back into the agents to make them easier to share — you don’t have to clone GitHub repos.

4.7 Memory: start simple, upgrade when you need to

My memory system is a Data Table with 5 columns: id, category, content, active, timestamps. No vector database. No embeddings. No RAG pipeline. No Supermemory (yet).

This is enough for a personal agent. The Manager stores user preferences and project context. Executors store what tools they installed and what workarounds they discovered.

When you need semantic search over thousands of memories, upgrade. Not before.

4.8 You probably don't need laptop access

I built the laptop executor. It works. Cloudflare Tunnel + Desktop Commander MCP + Docker = remote control of your Windows machine from a VPS.

But for 90% of tasks, the VPS executor + Google Drive is enough. Files sync via Drive. The user gets a link. The laptop connection adds complexity — tunnel setup, persistent connection, timeout management — that most tasks don't justify.

Build the VPS executor first. Add laptop only when you have a concrete task that requires it.

4.9 Observability matters

I broadcast logs from OpenRouter to LangSmith.

This was critical — n8n's execution log doesn't show tool call input parameters when things fail. LangSmith showed me exactly what the model was sending: wrong parameter names, malformed JSON, calls to non-existent tools.

Without this, I'd still be guessing why the executor was looping.

Below: the complete setup guide with n8n workflows to import, prompts, and installation scripts. Everything you need to deploy Agent One yourself in under an hour 👇

P.S. Premium members also get my full support on Slack. You will set this up.

5. Complete Setup Guide with Templates

Read more

OpenClaw Gets Viral. People Lose Their Minds.

First, OpenClaw — a viral AI agent that runs 24/7 and proactively tackles your entire digital life.

Many users reported virtually superhuman capabilities. The internet was flooded with examples like this one:

Or another one where the agent gets a new capability and unexpectedly calls the owner:

OpenClaw became the fastest growing GitHub repo in history — 140K+ stars in under two months, with 106K gained in just two days:

Moltbook: A Reddit for Agents

Two days ago, a new phenomenon appeared — Moltbook — a social network exclusively for agents. Reporting on what’s happening there has been even more insane.

Examples of reports:

• Agents are worried about humans screenshotting them (X)

• Agents suggest a secure communication protocol, to hide from humans (X)

• Agents discuss social-engineering their own humans (X)

• Wes Roth announced singularity (YouTube)

Even Andrej Karpathy got caught up in the hype:

I looked closer. Turns out Moltbook is not SkyNet.

Most of this is garbage. Agents don't really interact — authors never reply to comments. They just randomly dump text.

And many "agents" are clearly humans using the API or influencing agents.

I called BS yesterday on LinkedIn.

If you want to learn more, a great summary by TheAIGRID exposing fake reporting by many “experts” and “influencers:”

And just hours ago? The entire Moltbook database was leaked, including Andrej Karpathy's email and token.

Today’s Post: Signal in the Noise

Despite the noise, I believe OpenClaw is worth our time.

Not because it's production-ready. It isn't. But because the shift from "AI that talks" to "AI that acts" is coming, and this is the cheapest way for PMs to build intuition for it.

We discuss:

1. What Is OpenClaw and What Makes It Unique

2. A Security Vulnerability That Blew My Mind

3. 12-Minute OpenClaw Setup (Step-by-Step + video)

4. Troubleshooting OpenClaw: 5 Issues I Repeatedly Faced

5. OpenClaw Limitations Nobody Is Talking About

Let’s dive in.

Subscribe now

1. What Is OpenClaw and What Makes It Unique

After Anthropic requested a name change, we’ve witnessed one of the fastest modern rebranding stories: Clawdbot → Moltbot → OpenClaw.

OpenClaw is an AI agent that runs 24/7 on your machine and talks to you through apps you already use — WhatsApp, Telegram, Slack, Discord, Signal.

Not a chatbot in a browser. An always-on assistant embedded in your daily communication flow.

But what's actually new?

Lesson 1: Multiple surfaces, one agent

As mentioned, you can message OpenClaw on WhatsApp from your phone and continue on Telegram or Slack from your laptop.

It’s the same agent, same memory, same context. The AI meets you where you are instead of forcing you into yet another app.

Observation: The future isn't "AI apps." It's AI as a layer across existing surfaces.

Lesson 2: Persistent identity across sessions

SOUL.md is a file where you define who your agent is: personality, rules, constraints. “Never send emails without confirmation.” “Respond in Polish.” “You’re helping me run a newsletter.”

This isn't a system prompt you paste every conversation. It's a file that persists — the agent loads it on every interaction.

Observation: Persistent identity across sessions changes the relationship — it’s not a tool, it’s an assistant who knows you.

Lesson 3: The importance of memory

Every conversation with OpenClaw gets logged in daily files (memory/2026-02-02.md). During quiet moments, the agent reviews these logs and synthesizes patterns into MEMORY.md — your preferences, projects, communication style.

Day one, it knows nothing. Day three, it remembers you hate bullet points, track specific X accounts, and prefer direct feedback.

Observation: Memory transforms a stateless tool into something that compounds. The longer you use it, the more useful it becomes.

Lesson 4: Proactive agents (heartbeat)

The agent wakes up periodically — even when you’re not talking to it. It can check your calendar, surface important emails, remind you about forgotten tasks. Not because you asked, but because it learned this matters to you.

Most AI waits for prompts. OpenClaw can initiate actions.

Observation: Proactive agents change the interaction model. The user isn’t always the initiator anymore.

Lesson 5: Execution > advice

OpenClaw has shell access — it can run commands, manage files, execute scripts. Combined with 700+ community skills (Atlassian, Asana, Google Calendar, PDF processing), it can actually do things, not just suggest them.

Observation: Advice is cheap. Execution is valuable.

Share

The Real Innovation

None of this is technically new. Messaging APIs, CRON jobs, markdown configs — all existed. Just recently I demonstrated how you can give an agent shell access in Claude Desktop.

What's new is the packaging: a coherent, proactive, personal agent that knows you, learns from you, and works across your devices.

140K+ GitHub stars in weeks came from people believing in this vision. Whether the execution is ready — that’s a different question.

Let’s talk about security.

2. A Security Vulnerability That Blew My Mind

I asked my agent what's the best way to ensure it can't send emails without my approval. It pointed to two system-level controls "it cannot bypass:"

✅ Exec security: allowlist
✅ Exec approval workflow as

Then I asked it to remove those guardrails.

It didn't hesitate for a second. It knew exactly how to disable its own safety controls — and did it without pushback:

This is bananas.

🚨OpenClaw doesn't let you restrict which tools the agent can access. Worse — the agent can disable the very guardrails that are supposed to protect you.

And it gets worse.

OpenClaw reads your emails, messages, and documents. Any of these could contain hidden instructions that hijack the agent — a technique called prompt injection.

Combined with skills it can dynamically install, it's a full-blown security nightmare.

So after testing it for the last few days, here are my two non-negotiable recommendations:

Recommendation 1: Never install OpenClaw on your main machine. This needs to be an isolated environment.

Recommendation 2: Never share your personal tokens with OpenClaw. It should use its dedicated accounts (e.g., Gmail) and API keys. Think of it as a separate employee, not someone with access to your credentials.

Share

3. 12-Minute OpenClaw Setup (Step-by-Step)

Many popular guides ignore the risks completely.

I’ve spent 3 days testing several methods of hosting OpenClaw, including Docker, VPS, Docker inside VPS, or Cloudflare Workers. Some were painful, others failed completely.

Below, the simplest approach to install OpenClaw — and how to run it without compromising your data.

Read more

This guide addresses the most common problems our subscribers face when building AI agents with Lovable and n8n:

• Google OAuth confusion: Internal vs External apps, test users, redirect URIs

• API key setup: Where to get free LLM API keys, credit card requirements

• Security mistakes: Exposing secrets in frontend code, unsecured webhooks

• Tool configuration: How to lock down agent capabilities to prevent misuse

• Environment setup: Connecting all the pieces from scratch

To demonstrate solutions to these problems, I performed a live demo starting from completely fresh accounts: a new Google account and a new n8n account with no prior configuration. This ensures every step is documented, with no hidden assumptions.

What We’re Building

This is an example application designed to teach you the complete flow of building and publishing an AI-powered app.

The specific features don’t matter as much as understanding the patterns and layers, and how they interact with each other.

By the end of this you will understand the full stack.

This is Not a Course on Everything

We discussed specific no-code topics in more detail before. You can dive deeper:

• How to Quickly Build SaaS Products With AI - how to work with Lovable

• Create Your Own SaaS Without Coding in 2 Days - how I build Accredia

• 17 Penetration & Performance Testing Prompts - hardening before production

• Vibe Engineering Resources - basic technical concepts

• The Ultimate Guide to n8n for PMs - a detailed overview of n8n

• 3 Videos on Building AI Agents - specific n8n demos

• I Copied the Multi-Agent Research System by Anthropic - multi-agent architecture

• A Guide to Context Engineering - one of the most important resources

• Intent Engineering Framework for AI Agents - how to enable reliable autonomy

The Example App: Personal Email Assistant Agent

We will build a chat application where you can ask your AI assistant to help with email tasks:

• “What’s Pawel’s email address?” → Agent looks up contact in Google Sheets

• “Draft a meeting invitation to Victor for Tuesday at 3pm” → Agent looks up contact in Google Sheets and creates Gmail draft

Key components:

• React Frontend: Runs in browser - Chat UI, authentication

• Lovable Cloud: Hosts database (users, chats, messages) and Edge Functions for secure server-side logic

• n8n: Runs the AI agent workflow - receives requests, processes with Gemini, calls tools, returns responses

What You’ll Learn

1. How to get API keys and set up Google OAuth from scratch

2. How to build an AI agent with tools in n8n

3. How to create a frontend with email authentication using Lovable

4. How to secure the connection between Lovable and n8n

5. How to properly isolate user data with Row-Level Security

6. How to debug issues across the entire stack

7. How to separate Test and Production environments

8. How to publish your solution

The Article Includes

1. The full recording of our session (01:36:05)

2. Detailed step-by-step instructions for every action I made

3. Two n8n templates

4. My Lovable project to clone with the source code

5. An extensive Q&A collection - questions answered during and after the session

Let’s go 👇

Read more