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

Cowork is wild — local file access, long-running agents, and high autonomy. But it's Mac-only and lacks direct system access (Cowork runs sandboxed). It also doesn't learn across sessions by default (no memory).

Note: 15 minutes after publishing this post Anthropic made Cowork available to Claude Pro ($20/mo), not just Max ($100/mo). Still, only macOS, no memory.

Cowork just proved what I've been saying for months: you don't need a terminal for agentic AI work. Claude Desktop + Desktop Commander MCP had these capabilities all along—Anthropic just gave them a better UX.

Claude Desktop just did all this on my Windows PC:

1. Read a spreadsheet of 50 leads, researched each company, and drafted personalized outreach emails

2. Analyzed 47 interview transcripts on my Desktop, extracted opportunities and saved them to a new Notion database

3. Pulled data from 3 CSVs, created financial charts, and assembled a presentation (.pptx)

4. Analyzed audio files (.mp3) in a specific folder, transcribed them (.txt), and renamed files based on those transcripts

5. Installed Docker and then ran a new n8n instance - impossible with Cowork alone

6. Opened Gemini, asked it to generate a cyberpunk wallpaper, and set it as my wallpaper - impossible with Cowork alone

7. Visualized files from my desktop (an artifact + .xlsx)

8. Extracted images from a PDF

9. Scanned my Downloads folder, renamed files based on content, and organized into folders

10. Resized 278 product screenshots, added watermarks, and added the date to the file name

11. Analyzed GitHub history and wrote release notes for customers (.md + .pdf)

Over time, it’s also learned my preferences and how to avoid past mistakes.

In this issue:

1. Examples of What You Can Do Today With Claude Desktop

2. Specific Claude Extensions I’ve Used and How to Configure Them (work also with Cowork)

3. My Custom Claude Desktop Instructions for an Agentic Behavior + Cross-Session Learning on Windows

Let’s dive in.

Free AI Skills’2026 Virtual Conf on Jan 22

Before we continue, I'd like to invite you to join me & 10,000+ (updated) AI professionals on Zoom at the AI Skills'2026 Virtual Conf on Jan 22.

This is a free event we organized with and the God of Prompt. Speakers include leaders from Google, Microsoft, and Miro.

Register for free: https://conf.cosprints.ai?4

Topics include:

• AI Superpowers: Can one person build a unicorn?

• MCP, AI Agents, AI Skills, Automations & Prompting

• How to make 16M views on LinkedIn in 3 months with AI

• What are the must-have AI Tools & Skills for Career and Business Growth in 2026

A full agenda is available here.

1. Examples of What You Can Do Today With Claude Desktop

Example 1: Draft 50 personalized outreach emails based on leads.csv

Prompt:

Analyze a spreadsheet with 50 leads in C:\Users\Dell\Desktop\Product Cases\Leads, research each company, and draft personalized outreach emails in my Gmail.

Results:

Example 2: Analyze interview transcripts, extract opportunities, and save them to Notion

Prompt:

Analyze ~50 interview transcripts in C:\Users\Dell\Desktop\Product Cases\Transcripts, aggregate opportunities:
• Title
• Description
• Importance (0-1)
• Satisfaction (0-1)
• Opportunity score by Dan Olsen (Importance * 1-Satisfaction)
• # of users affected

Next, save them in my Notion collection as a new database under [url]

Results (I added bars manually):

Example 3: Pull financial data from csv files, assemble a presentation (.pptx), and send it by email

Prompt:

Analyze the CSV files in C:\Users\Dell\Desktop\Product Cases\CSVs (costs.csv, customers.csv, sales.csv) and create a PowerPoint presentation with the following reports:

1. Customer Acquisition & Profitability
2. Revenue Growth & Churn Analysis
3. Operational Efficiency & Profitability

Include charts. Email the finished presentation to pawel@productcompass.pm

Results:

Example 4: Analyze recordings (.mp3), transcribe them (.txt), and rename based on those transcripts

Prompt:

Analyze interview recordings (mp3) in C:\Users\Dell\Desktop\Transcribe and transcribe them to .txt (use the same file name).

Finally, rename all files based on the beginning of the transcript.

Results:

Example 5: Install Docker and run a new n8n instance

Prompt:

Configure a new Docker container with a free n8n edition and start it

Results (impossible with Cowork alone):

Share

Example 6: Use Nano Banana to create and apply a new desktop wallpaper

Prompt:

Go to https://gemini.google.com/app
Generate a cyberpunk desktop background with Nano Banana
Set it as my desktop background

Results (impossible with Cowork alone):

Example 7: Analyze video files and visualize their distribution

Prompt:

Find all video files on my desktop. Visualize their distribution and size.

Results:

Example 8: Extract images from a PDF

Prompt:

Extract images from C:\Users\Dell\Downloads\Documents\INVITE.pdf and save them in C:\Users\Dell\Desktop\PDF Images

Results and the process:

Example 9: Scan the Downloads folder and organize files into folders

Prompt:

Scan my Downloads folder, rename files based on content, and organize into folders by file type. Optimize for performance. Finally, summarize what you did.

Results:

Example 10: Resize product screenshots, add watermarks, and rename by date

Prompt:

Analyze screenshots in C:\Users\Dell\Downloads\Screenshots. 

Next: 
1. Copy them to \Modified
2. Resize to no more than 800x600 px
3. Add a white, semi-transparent watermark "The Product Compass" in the middle
4. Add creation date as a file prefix ("yyyy-MM-dd ")

Results and the process:

Example 11: Analyze GitHub history and write release notes for customers

Prompt 1:

Analyze GitHub history from the last 3 months using GitHub MCP for the main branch in /phuryn/cred-craft-forge-60/  (Accredia)

Write short release notes for customers as .md file on my desktop.

Prompt 2:

No, convert it to PDF

Results and the process:

2. Specific Claude Extensions I’ve Used and How to Configure Them

When working with Claude Desktop, you need to enable certain extensions yourself - but they're valuable to Cowork users too!

Desktop Commander MCP

The most important one is Desktop Commander MCP, that allows Claude to interact with your files and run real shell scripts (e.g., PowerShell). You can enable it here:

Share

On macOS, you can use the same MCP, even though you can also choose “Control your Mac.”

Claude in Chrome

This extension allows Claude Desktop or Cowork to control your browser and fully impersonate you. I’ve used it in Example 6 to generate a wallpaper with Gemini and Nano Banana.

You can approve operations for specific domains, so Claude won’t ask you for permission before taking action.

More: https://claude.com/chrome

Claude Built-in Connectors

One of the examples I presented involved Notion. This and many other connectors are available in the Claude catalogue and are easy to configure:

Some of them, especially Google products, provide read-only access. Many other products do not appear in that catalogue. You can fix that with MCP servers.

Custom MCP Servers

I’ve used the following MCP servers (can be used with Claude Desktop and Cowork):

• ElevenLabs MCP for audio translation. It can also generate voice or translate audio files. More: https://github.com/elevenlabs/elevenlabs-mcp An alternative is asking Claude to find and install a free, local library (or just do nothing, it will try to find a solution autonomously — more in the next point).

• Gmail MCP to draft and send emails. This is not possible with standard Gmail connector (read-only). More info and instruction (requires several steps, 100% doable): https://github.com/GongRzhe/Gmail-MCP-Server

• GitHub MCP to analyze the history of codebase. More: https://github.com/github/github-mcp-server

You can configure them after clicking Developer > Open App Config File… in Claude Desktop. You can start with my working configuration. Use your API tokens:

{
  "mcpServers": {
    "playwright": {
      "command": "npx",
      "args": [
        "@playwright/mcp@latest"
      ]
    },
    "ElevenLabs": {
      "command": "uvx",
      "args": [
        "elevenlabs-mcp"
      ],
      "env": {
        "ELEVENLABS_API_KEY": "sk_********"
      }
    },
    "gmail": {
      "command": "npx",
      "args": [
        "@gongrzhe/server-gmail-autoauth-mcp"
      ]
    },
    "github": {
      "command": "C:/******/github-mcp-server.exe",
      "args": ["stdio"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "********"
      }
    }
  }
}

I didn’t know how to configure GitHub. I asked Claude for help and it came up with the correct format based on documentation.

You can find hundreds of other MCP servers here: https://github.com/modelcontextprotocol/servers

Or just ask Claude to find them, install, and configure. With the Desktop Commander MCP, it can change its own configuration!

Remember to set permissions

After enabling a connector or an MCP server, set permissions, so you don’t have to approve every action.

For example, my Gmail MCP should be able to draft emails, but I want to approve every email. I should change this setting:

Question from the community: Aren't you worried about not sandboxing and giving it so much power on your desktop?

That's a valid concern. You can adjust approval settings for each tool or enable/disable MCPs depending on the context.

For example, I demonstrated sending emails automatically, but I don't trust it enough to keep that setting on - sending an email still requires my approval.

I also allowed Claude to do whatever it needed to install Docker and n8n, but I was watching the screen.

Consider configuring Claude to ask for approval before executing shell commands - it’s the "start_process" tool. That’s, by far, the most powerful tool.

Claude Desktop can also run scripts on its own, in a sandbox environment. So it can read files from Google Drive and analyze them there, and even create a PowerPoint presentation for you to download. It just can't save the results of those scripts outside sandbox.

What can't be sandboxed is Claude in Chrome, which won't protect you from prompt injection, or MCPs that modify data in external systems - true for both Claude Desktop and Cowork.

We're early and we haven't fully figured out permissions. In my opinion, the biggest threat is not AI going wild and doing something crazy on its own, but prompt injections, e.g., in a received email.

You need to continuously assess the risk. The impact is smaller when it involves local files and you have cloud backups. It's larger if that agent is part of a product serving thousands of users - you need to approach this methodically:

Custom skills

You can also explore custom skills. Claude can help you create them. We will cover Skills another time.

When using the setup I present later in this post, Claude Desktop can learn by creating “dynamic skills” based on its mistakes and your feedback. You can also ask it to remember things, e.g., meeting notes format.

Note: Claude Cowork can also dynamically adds predefined skills to the context.

More: https://support.claude.com/en/articles/12512198-how-to-create-custom-skills

Custom files

Just like in any Claude project, you can add custom files (e.g., a PRD template) that agents will use when working on your tasks.

This works similarly when setting context for Cowork.

3. My Custom Claude Desktop Instructions for Agentic Behavior + Cross-Session Learning on Windows

While Claude Cowork is a game-changer, it's currently available only to macOS users. It also can't learn across sessions (memory is not supported yet).

Meanwhile, Claude Desktop + Desktop Commander MCP gives you:

• async, long-running work

• full file access

• Claude in Chrome

Unlike Cowork alone, it can also execute scripts directly on your machine (not in a sandbox) and run system commands.

That's how it was able to install Docker and run an n8n container, configure its own MCP, and change my wallpaper.

Claude Cowork feels different because it ships with a preset and a better UX.

After configuring MCP servers, the main capability missing is an explicit execution contract: custom instructions that encourage autonomy and persist progress for jobs and tasks.

To fix that, I created a dedicated Claude project with a set of custom instructions.

Notes:

• This setup was tested on Windows OS.

• The framework supports multiple autonomous agents working in parallel. But on Windows, Claude Desktop simply doesn’t support multiple chats with MCP server calls well. You can work with one chat thread and use the web interface for other queries. In case of any issues, type /resume so that the agent can continue. I hope Anthropic will fix that soon.

The extensions from point 2 work. But without custom instructions, they're one-shot—Claude Desktop asks questions, waits for approval (even with high permissions), loses context when you close the chat.

The custom instructions below turn Claude Desktop into a persistent autonomous agent that:

• Runs 30-60 minutes without interruption

• Resumes exactly where it left off after a crash or reboot

• Logs lessons and gets smarter across sessions (not supported in Cowork yet)

This is the execution contract that makes Claude Desktop feel like Cowork on Windows + an agent that can truly learn 👇

Read more

Agents fail not because they can’t reason. They fail because their objectives, outcomes, and constraints are underspecified. The solution isn’t more detailed instructions.

This guide breaks down intent engineering into something you can actually use.

In this issue, we discuss:

1. What Intent for AI Agents Actually Means

2. The AI Agent Intent Structure

3. The Flow: How to Use the Intent Engineering Framework

4. Complete Example: Customer Support Agent

5. AI Agents Intent Validation Checklist

6. Conclusion

Let’s dive in.

Subscribe now

1. What Intent for AI Agents Actually Means

Intent is not:

• A task list

• A prompt

• A goal metric

Intent is what determines how an agent acts when instructions run out.

When intent is incomplete, humans draw on knowledge that was never written down. Agents can’t. They only know what you’ve codified. And most organizations have codified far less than they think.

Tobi Lütke, CEO of Shopify, said:

“I like the term context engineering because I think the fundamental skill of using AI well is to be able to state a problem with enough context, in such a way that without any additional pieces of information, the task is plausibly solvable.”

But context without intent is noise.

We discussed context engineering previously. In this issue, I double down on the intent: how to define it clearly in a way that survives real-world edge cases.

Share

2. The AI Agent Intent Structure

Whether you’re setting team objectives, delegating to a human, or configuring an agent, the structure is the same:

1. Objective: The problem to solve + why it matters

2. Desired Outcomes: Measurable states that indicate success

3. Health Metrics: What must not degrade while pursuing the outcomes

4. Strategic Context: The system we operate in

This pattern shows up in OKRs, as defined by Christina Wodtke, and in how Marty Cagan defines empowered team objectives.

For agents, we extend this with explicit:

5. Constraints: Steering (prompt layer) + Hard (enforced in orchestration, not prompts)

6. Decision Types and Autonomy: Which decisions the agent may take autonomously vs. must escalate

7. Stop Rules: When to halt, escalate, or complete

Let’s build this up.

Part 1: The Objective

Definition

The objective defines the problem being solved and why it matters. It is aspirational and qualitative. It guides judgment when trade-offs arise.

What a good objective does

• Problem-focused: What’s broken or missing?

• Explains why it matters: Business value, user impact, strategic importance

• Guides trade-offs: When the agent faces ambiguity, the objective helps it choose

Example

• Weak: “Handle customer support tickets”

• Better: “Help customers resolve issues quickly so they can get back to work, without creating more frustration than they started with.”

When you explain the why, the agent can reason about edge cases and make better autonomous decisions. I demonstrated that in How to Build Autonomous AI Agents. A 2024 paper (arXiv:2401.04729) demonstrated that supplying strategic context beyond raw task specifications significantly improves AI autonomy.

Part 2: Desired Outcomes

Definition

Desired outcomes are observable states that indicate the objective has been achieved. They are not activities.

Rules for good outcomes

Outcomes should be:

• Observable state changes (not activities the agent performs)

• From user/stakeholder perspective (not the agent’s perspective)

• Measurable or verifiable (without relying on agent self-report)

• Leading, not lagging (observable during or shortly after, not months later)

Activities describe what the agent does. Outcomes describe the state that exists after.

Example:

Two to four outcomes is usually right. More than that and you’re either micromanaging or unclear on what actually matters.

Objective: Help customers resolve Tier-1 issues without frustration

Desired Outcomes:
- Customer confirms their issue is resolved
- No follow-up ticket on same topic within 24 hours
- Customer rates interaction as helpful

Each outcome is observable, measurable, and from the customer’s perspective.

Part 3: Health Metrics

Definition

Health metrics (used here as non-regression metrics) define what must not degrade while optimizing for outcomes.

The Goodhart problem

“When a measure becomes a target, it ceases to be a good measure.”

Without health metrics:

• “Resolve issues faster” → Agent rushes, quality drops

• “Increase throughput” → Agent takes shortcuts

• “Reduce escalations” → Agent handles things it shouldn’t

Health metrics inform trade-offs

Health metrics primarily inform the prompt layer. They guide how the agent thinks and makes trade-offs.

Health Metrics:
- CSAT must stay above 4.2 - if trending down, be more conservative
- Repeat contact rate must not increase above X - prioritize resolution quality
- Escalation quality score must stay below Y - don't under-escalate to hit targets

These metrics inform how conservative the agent should be when making trade-offs

This is different from hard guardrails, which block actions entirely. Health metrics steer; guardrails enforce.

Share

Part 4: Strategic Context

Read more

• an LLM workflow

• an AI agent (low autonomy)

• an autonomous AI agent

We also discussed:

• Building multi-agent systems

• How to (ethically) hack the free n8n version from Hostinger

• Best practices and common mistakes

The recording is 100% free. n8n will help you:

• Build a deep intuition for AI agents and multi-agent systems without coding.

• Automate your repetitive tasks (market research, product discovery, SEO, etc.).

• Integrate with virtually any system (1,000+ integrations)

• Demonstrate an AI PM portfolio with RAG, AI agents, and multi-agent systems.

• Implement a backend or background jobs for your vibe-engineered products.

You can watch it for free on YouTube:

Some of the takeaways summarized by Aakash:

1. n8n combines traditional workflow automation AND AI agent building in one platform. Makes it more powerful than Zapier or Make for complex automation needs.

2. Real use cases span from simple business workflows to chatbots, competitor monitoring, multi-agent research systems, and inbox workers. Sky is the limit.

3. Pawel's competitor monitoring workflow costs $1-2/week using the FREE version of n8n. Just needs Perplexity API and OpenAI credits. Enterprise tools charge $500+/month.

4. Pin your data during development. n8n caches API responses so you don't burn credits while testing workflows. Click the pin icon and work with cached data.

5. n8n automatically loops through items. No for-loops needed. When you connect a node with 6 items, n8n repeats the action 6 times automatically.

6. Compress context before sending to LLMs. Pawel cuts 70% of tokens by extracting only summary content and citation URLs, ignoring irrelevant snippets.

7. Use ChatGPT to write n8n code snippets. Pawel never writes code blocks himself. Just screenshots data and asks GPT "how do I compress this?"

8. Traditional workflows beat AI agents for predictable tasks. Workflows save tokens and rarely hallucinate. Agents are flexible but use more tokens and make mistakes.

9. Set GPT reasoning effort to "low" for simple tasks. When you just need formatting or summarization, low reasoning effort saves tokens significantly.

10. Best practices: Set error probes, use max iterations to prevent infinite loops, retry on fail 3x, pin data during dev.

The podcast is available also on:

• Spotify: https://open.spotify.com/show/7vVEMqCSKb7I7xPk8xZtg5

• Apple: https://podcasts.apple.com/in/podcast/product-growth-podcast/id1763555775

And that’s not all.

🎁I also removed a paywall from The Ultimate Guide to n8n for PMs. You can access all templates, examples, and cheat codes for free here:

Complete Course: AI Product Management

For those interested, my previous recording with Aakash is still #1 on his channel with 56K views:

How to Build Autonomous AI Agents

Another useful, complementary video:

More information is available here:

Housekeeping

We have migrated all video courses from Kajabi (old video courses) to Accredia:

• Continuous Product Discovery Masterclass

• From Strategy to Objectives Masterclass

• Product Innovation Masterclass

FAQ

Q: How to enroll?

All video courses are free for premium members. After upgrading your account, you can enroll here: https://go.productcompass.pm/premium

Subscribe now

Prerequisite: sign up with your Substack email address. Benefits will be linked by email. This is the same account Accredia uses, not your Substack account.

Q: What about my old certificates?

Your certificates and course enrollments have been migrated to Accredia.

If you used the same email on Substack and Kajabi, you will see everything here: https://go.productcompass.pm/premium

If not, you can keep two separate accounts or use a certificate transfer option (coming later).

Q: Can I finish the course I started on Kajabi?

Until January 31, you can finish courses you started in Kajabi. Certificates will be migrated. Later, Kajabi will be turned off.

After January 31, as a premium member, you can enroll again. You won’t see your old progress, but exams do not require re-watching all lessons.

Let me know if you have any questions: pawel@productcompass.pm

Q: How was it implemented?

No code. Lovable + n8n :) You can read more here:

The Next Newsletter Issue

It will be published on Monday. Tomorrow we’re starting the AI Agents Buildathon for PMs (registration closed, subscribe to participate in the next edition).

In the meantime, you might have missed:

• 2026 Is Here. Stop Watching AI Models. Start Designing AI Systems.

• A Guide to Context Engineering for PMs (my favorite)

• How to Build a RAG Chatbot Without Coding

• 5 Phases To Build, Deploy, And Scale Your AI Product Strategy

• The AI Product Pricing Masterclass

Subscribe now

Have an amazing weekend,
Paweł

2026 is here, and the shifts are already visible. Autonomous coding hitting the mainstream. ARC-AGI-2 scores above the human average.

Separating signal from noise keeps getting harder.

So, today, we cover:

1. AI in 2025: Recap

2. What the Labs Are Working On?

3. What to Focus On in 2026

This is highly curated, based on my observations, experiments, and papers I’ve been reading, not common sources.

Seatbelts on. Let’s go.

Subscribe now

1. AI in 2025: Recap

1.1 The rise of agentic AI

Throughout 2025, the mainstream narrative about AI agents was a few months behind the actual capabilities.

In mid-2025, the term “agentic AI” took off. Early definitions framed it as systems that could plan, decide, and execute goals with minimal human supervision.

The problem?

Reality lagged that framing. Reliable autonomy wasn’t there yet, despite social media and consulting firms repeating “agentic AI” like a mantra.

I won't lie - I got frustrated watching people post about "agentic AI" without experimenting or talking to practitioners (e.g., the AI Evals Cohort community I’ve been consulting).

I called this out several times:

In June 2025, agents still couldn’t reliably handle more than 2-3 tool calls. This was visible in the Agent Leaderboard by Galileo:

Then, on August 7, 2025, GPT-5 radically reduced hallucinations and improved instruction following. I didn’t trust OpenAI, so I confirmed this by running experiments like this one:

In October 2025, I ran another experiment, in which a fully autonomous agent succeeded 185/185 times, despite having no step-by-step instructions in the prompt:

This helped me confirm that instead of complicating instructions, we should double down on explaining the why (strategic context, objectives, and how success will be measured) - we previously covered that in A Guide to Context Engineering for PMs.

Later, I demonstrated how to build autonomous agents in this lighting lesson:

Surprisingly, in November–December 2025, the social media narrative shifted to “agents don’t work.” We also saw a backlash against AI rising:

While there are many reasons for that backlash, what actually happened with capabilities was the opposite: agents stopped being toys.

By late 2025, agents became reliable in scoped workflows, once hallucinations dropped and planning, instruction following, tool use, evals, guardrails, and recovery matured.

The progress didn’t stop. I kept running experiments like this one, where top LLMs played chess. Every model iteration turned out to be stronger than the previous one.

Just a few days ago, I noticed this graphic posted by Brij kishore Pandey:

Someone finally made sense of “agentic AI.” The term was repurposed to match reality: agents + observability + governance + evals + agentic protocols.

I loved it.

1.2 The rise of vibe engineering

Throughout 2025, I kept repeating that progress in AI coding was crazy. In September 2025, I started talking about vibe engineering:

This term was my attempt to emphasize that you don’t have to code, but you can’t ignore engineering — I learned that by experimenting with projects like Accredia (currently, a B2B2C video course platform supporting our community):

Here we are a few months later. What’s happened in the last 1–2 weeks has been wild:

• Senior Google engineer: Claude did in 1 hour what took Google 1 year:

  

• Karpathy (OpenAI co-founder) says AI could make him 10x powerful:

  

• Engineers admit they’ve stopped coding (reported by a former Google engineer and the founder of the coding interview preparation website and platform NeetCode.io):

  

• The evidence keeps spreading on Reddit:

  

January, 2026:

• You don’t have to code or even carefully review everything an agent creates.

• What you do need is to ask good questions, understand the architecture, design tests, and interpret simple snippets in a chat window. Keep asking questions and pushing back until you understand the architecture, risks, and tradeoffs.

Some helpful prompts:

1.3 ARC-AGI-2 crushed

On December 11, GPT-5.2 dropped. Many people focused on GDPval (knowledge-work tasks), but what caught my attention was something else: it scored 52.9% on ARC-AGI-2.

ARC-AGI-2 is not a random benchmark. It’s designed to be difficult for AI and to minimize simple pattern matching. The average human score is 60%.

Surprisingly, that wasn’t the end of the story. Just before the New Year, Poetiq hit 75% on ARC-AGI-2 through orchestration, not a better model:

I don’t believe ARC-AGI-2 represents AGI (however we define it). But this clearly demonstrates progress beyond pattern-matching capabilities.

Share

2. What the AI Labs Are Working On?

Virtually every day, new AI papers drop. It’s impossible to track everything.

For example, on December 31, 2025, DeepSeek released a fundamental improvement in transformer architecture: mHC: Manifold-Constrained Hyper-Connections.

Zooming out, all these algorithmic and architectural improvements eventually leave the labs, compound, and get absorbed into frontier models.

My 2026 prediction: We’ll see more jumps in capabilities, and once trust catches up, adoption will spike.

There are only two trends I want to highlight.

2.1 Continuous Learning

One key weakness of LLMs is their inability to learn at test time (despite papers like Agentic Context Engineering, which are more helpful techniques/workarounds than true solutions).

Google's Titans + MIRAS architecture, last refreshed on December 4, 2025, demonstrated a path toward long-term memory and models that can learn from experience during test time without catastrophic forgetting.

In early tests, this drastically improved accuracy for extremely long contexts, despite using far fewer parameters:

A Google engineer recently predicted:

Note for PMs and builders: These are AI-lab timelines, not when reliable capabilities actually reach production.

2.2 Harness

AI engineers often talk about “harness.” You can think of it as a safety and control layer around a model.

As Poetiq’s 75% ARC-AGI-2 result showed, you don’t need a better model to get better outcomes.

A Stanford paper from December 5, 2025, argues that LLMs are just the substrate. The real leverage is the orchestration layer you ship: how you coordinate multi-agent systems so they stay grounded and correct.

My translation (not their wording):

• RAG for grounding

• Context engineering for guiding

• Tools for action

• Verification loop for correctness

• Guardrails for safety

• Memory, scratchpads, and task lists for continuity

• Roles for separation of concerns

Once the context and orchestration give the model enough support, outputs can change dramatically. We’re already seeing this with Claude Code.

Takeaway for PMs and builders: Stop judging “the model” in isolation. Most gains come from orchestration: retrieval, tools, memory, verification, and guardrails. AI evals help you iterate, prove it works, and monitor drift.

Leave a comment

2.3 Why waiting for the next model is already late

If you’re waiting for “the next model” to unlock value, you’re already late.

The biggest gains in 2026 won’t come from raw model upgrades. They’ll come from better orchestration, clearer intent, tighter evals, and teams who know how to design systems around AI, not just call APIs.

Share

3. What to Focus On in 2026

If 2025 was about capability catching up with hype, 2026 is about leverage.

The gap is no longer what models can do, but who knows how to use them best. Under real constraints: messy data, partial autonomy, human oversight, and business risk.

Here are the five key areas I want to highlight.

3.1 Product Discovery (still wins)

You might expect me to say “go AI-first.” I won't.

Because product discovery still defines whether you’re solving a real problem or just automating noise. I explained that also in WTF is AI PM.

AI reduces build cost, not the cost of being wrong.

You can’t build random things and throw spaghetti at the wall. You still need to:

• Explore the problem space,

• Identify real opportunities,

• Form clear hypotheses,

• Test assumptions deliberately.

AI lets you prototype, test, and discard ideas at unprecedented speed. But discovery decides where that speed is applied.

More & link to a video course free for premium members:

3.2 Developing AI intuition beats learning AI tools

AI tools change every few months. Mental models compound.

The best way to develop real AI intuition, understand what’s possible, and internalize the details that matter is to roll up your sleeves and build.

Our AI PM Learning Program is designed for that:

• Part 1: C11 LLM Practitioner Certified PM

• Part 2: C21 AI Agents Practitioner PM

As for tools, you need surprisingly few. You can start with:

• Lovable / Google AI Studio / Dyad (build without friction)

• Perplexity (research)

• n8n (orchestration)

• NotebookLM (research, structure)

• Claude Code or Claude Desktop + Desktop Commander (Claude Code is amazing for developers, Desktop Commander enables file access and shell commands without terminal and can support many common PM tasks)

3.3 Areas to double down on

Read fewer things. Two posts studied deeply beat thirty skimmed once.

Understanding context engineering and AI evals covers some of the most critical insights I’ve seen recently:

• The importance of expressing the intent:

  • Most agent failures I see are not model failures, but intent failures.

  • Remember to start with Why not What.

  • When given the strategic context, agents usually can make reasonable assumptions.

• Defining what the good behavior is:

  • Start with Evals, not instructions.

  • You’re unlikely to get instructions or examples right without data and iteration.

Some of the most important pieces of the newsletter:

• A Guide to Context Engineering for PMs

• Error Analysis (not easy, but critical)

3.4 Product strategy, distribution, and pricing

When building becomes cheap, strategy becomes expensive.

This aligns with what I first noticed working at Ideals (my last and favorite company, I still wear their t-shirt): PMs were expected to explore the market, contribute to strategy, and identify expansion opportunities.

Useful reads:

• How to Create AI Product Strategy

• 5 Phases to Build, Deploy, and Scale AI Product Strategy

• 3-Layer AI Distribution Framework

• The AI Product Pricing Masterclass

3.5 Career shift and the future of PM

You don’t have to code. But roles in AI require increasingly more engineering (resources discussed here).

This is already visible:

• Meta explicitly expects PMs to vibe-code

• LinkedIn launched the Associate Product Builder Program

Your goal is to drive value, not stay in your comfort zone. Whatever the PM role becomes, think of yourself as someone who solves problems at the intersection of business, users, and technology.

There have never been more opportunities.

Even as traditional roles increasingly overlap.

—

If you want to transition into AI PM, don’t start with a resume.

Solve a real problem or identify an opportunity instead, like did by proposing an AI Agents Buildathon for PMs (not my idea!).

That was the first time I’d seen someone approach it this way.

This and other “unfair strategies” top AI PM candidates rely on are described here (a coincidence).

Thanks for Reading The Product Compass

2026 is here. The leverage shift has begun.

Start building. Stop theorizing. We're just starting.

For dozens of AI PM resources, see The Ultimate AI PM Learning Roadmap and our articles archive.

Subscribe now

Have an incredible 2026,
Paweł

Each week, I share actionable insights and resources for AI PMs. Here’s what you might have missed:

• Your Complete Roadmap to Earning a $180K–$569K AI PM Role

• 5 Phases To Build, Deploy, And Scale Your AI Product Strategy

• 5 GTM Principles You Should Know as a PM

• A Guide to Context Engineering for PMs (one of the most important posts)

I just released a new premium section and a new archive of articles.

Subscribe and upgrade for the full experience:

Subscribe now

This is a guest article written in collaboration with , Product Lead at OpenAI. I work with Miqdad as AI Labs Build Leader for the AI PM Certification Cohort.

In traditional SaaS, the system’s behavior is deterministic. You click a button, the same logic runs every time. Costs also behave nicely: once you amortize infrastructure, the marginal cost of serving one more user trends toward zero.

Pricing models grew up around that reality. Seats, tiers, bundles, “unlimited” plans. The core assumption was simple: more usage is good, because costs flatten as you scale.

AI flips that assumption.

In AI systems, the product does not just execute code. It reasons. And reasoning is not free. It is variable, sometimes unpredictable, and often unbounded unless you explicitly design it to be.

Every interaction triggers a cascade of costs that depend not just on how many users you have, but on how they behave, what they ask, how often they retry, how complex their workflows become, and how much parallel demand they create.

This is why AI pricing is not an extension of SaaS pricing. It is a different discipline altogether.

In this post, we discuss:

1. Why AI Product Pricing Is Fundamentally Different From SaaS

2. The Real Cost Structure of AI (The 7 Layers)

3. The Four AI Pricing Models (and When to Use Each)

4. 🔒 Stability vs Scale: The Strategic Tension

5. 🔒 How to Choose Your AI Pricing Model: A Decision Tree

6. 🔒 AI P&L: A Full Unit Economics Breakdown

7. 🔒 Conclusion

8. 🔒 AI Cost Glossary

Let’s dive in.

1. Why AI Product Pricing Is Fundamentally Different From SaaS

1.1 The death of “zero marginal cost” thinking

The most dangerous SaaS habit AI teams carry forward is the belief that marginal cost eventually disappears. In AI, it never does.

Every meaningful AI interaction has a real cost attached to it: not just tokens, but compute allocation, latency trade-offs, orchestration overhead, retrieval, and often retries or fallback paths.

There is no finish line where you’ve “paid the cost once” and can now scale freely.

Even worse, the marginal cost isn’t stable. It changes as your product evolves, as users get more sophisticated, and as edge cases accumulate.

The same feature that was cheap at launch can become expensive six months later simply because users learned how to push it harder.

In SaaS, growth tends to smooth costs. In AI, growth often amplifies them.

This is the first mental shift pricing must reflect: your AI system remains economically alive forever.

1.2 Costs scale with behavior, not just users

In SaaS, two customers on the same plan usually cost roughly the same to serve. In AI, two customers paying the same amount can have radically different cost profiles.

One user might ask short, well-scoped questions, accept imperfect answers, and move on. Another might run long, iterative workflows, repeatedly refine prompts, trigger multiple retries, and expect high accuracy every time.

From a pricing perspective, these two users look identical. From a P&L perspective, they are opposites.

This is what makes AI pricing unintuitive. The thing you celebrate (engagement) is often the thing that destroys margins if it isn’t constrained or monetized properly.

Traditional pricing assumes usage correlates with value. AI breaks that assumption.

Usage correlates with cost volatility, not guaranteed value. Some of the most expensive interactions are exploratory, redundant, or compensating for system weaknesses rather than delivering incremental benefit.

That means pricing can no longer be passive. It has to shape behavior.

If your pricing doesn’t influence how users interact with the system, the system will eventually influence your margins instead.

1.3 Variance is the real enemy

Most teams obsess over average cost per request. That’s the wrong metric.

AI systems don’t fail on averages. They fail when real usage creates variance.

Variance shows up everywhere: prompt length, context size, retries, parallel usage spikes, long-tail edge cases that require heavier models, and moments where the system has to work much harder to maintain quality.

SaaS pricing models assume variance is negligible. AI pricing models must assume variance is inevitable.

The uncomfortable implication: pricing must be designed for worst-case behavior, not typical behavior. If your pricing only works when users behave “nicely,” it doesn’t work.

This is why many AI products look profitable in early metrics and then fall apart as usage deepens. Early users are forgiving and exploratory. Later users are demanding and efficient at extracting value which usually means extracting cost.

1.4 AI pricing is a system control mechanism

Here’s a framing most teams miss: pricing in AI is not just a way to charge money. It is one of the strongest control mechanisms you have.

Pricing determines:

• how often you invoke reasoning

• how much you experiment

• whether you batch work or stream it

• whether you tolerate latency

• whether you retry aggressively

• whether you push the system to edge cases

In SaaS, pricing mostly controls access. In AI products, pricing controls behavioral pressure on the system.

If pricing encourages unbounded exploration without cost feedback, you will push the system until it breaks.

If pricing is too restrictive too early, you will never discover value.

Great AI pricing doesn’t just extract revenue. It teaches you how to use the product in a way the system can sustainably support.

1.5 Why “fair” pricing is a trap

A lot of early AI products aim for fairness: flat plans, simple tiers, “unlimited” usage with soft limits. It feels user-friendly, and in the short term it often boosts adoption.

But fairness is not the goal. Survivability is.

AI pricing that feels fair but ignores variance transfers all risk to the company while giving you no incentive to behave efficiently.

Over time, the system absorbs more stress until engineering adds silent limits, quality degrades, or finance forces abrupt pricing changes that anger customers.

The irony: “unfair” pricing that reflects real costs and constraints often builds more trust in the long run.

You can tolerate explicit limits. What you hate is inconsistency: unpredictable throttling, sudden downgrades, or quiet degradation.

Honest pricing aligned with system reality beats generous pricing that lies.

1.6 The PM role changes here

This is where the AI PM role diverges from traditional product management.

In SaaS, PMs could largely ignore pricing mechanics once tiers were set. In AI, PMs cannot. Pricing decisions influence architecture, and architectural decisions influence pricing viability. You cannot separate the two.

An AI PM must understand:

• which user actions are expensive

• which costs are fixed vs variable

• which behaviors create cascading load

• which quality improvements are linear vs exponential in cost

Without this, PMs accidentally design features that are economically incompatible with the pricing model.

The product looks great, usage climbs, and finance quietly panics.

AI pricing failure is rarely one bad decision. It’s a slow accumulation of small misalignments between system behavior, user behavior, and pricing assumptions.

1.7 The core AI pricing mistake, stated plainly

The most common mistake teams make is pricing AI as if cost is something to optimize later.

In AI, pricing is system design, not a go-to-market tweak.

It decides who absorbs variance and which behaviors your system must constrain under real user pressure.

If you don’t design pricing with the same rigor as system architecture, the system will expose that weakness at scale. Not immediately. Not loudly. But inevitably.

SaaS taught us to chase growth first and fix economics later. AI punishes that mindset.

Growth without pricing discipline is not momentum. It’s deferred failure.

Everything builds on this foundation: AI pricing is different because AI systems never stop costing money, never behave predictably, and never forgive lazy assumptions.

If you accept that early, pricing becomes a strategic weapon. If you don’t, it becomes the reason your product dies quietly while “everything looked fine.”

Share

2. The Real Cost Structure of AI (The 7 Layers)

If you ask most teams where their AI costs come from, they’ll say “tokens.”

That answer is understandable, visible, and dangerously incomplete.

Tokens are the easiest cost to see because they show up cleanly on invoices, dashboards, and alerts. But in real AI systems, tokens are rarely what kills you.

What kills you is everything around them: the quiet layers that compound, interact, and magnify each other until your unit economics collapse while your token graphs still look “reasonable.”

To price AI correctly, you have to understand its true cost structure not as a single line item, but as a layered system where inefficiencies stack.

I’ve found the most accurate way to think about AI cost is as seven layers, each one capable of quietly multiplying the next.

2.1 Layer 1: Data preparation and upkeep

This is where most teams underestimate cost before they even ship.

AI products don’t run on “data” in the abstract. They run on data that has been cleaned, structured, embedded, versioned, and kept up to date.

Every document you ingest eventually needs reprocessing. Every schema you introduce creates maintenance overhead. Every shortcut you take early turns into recurring cost later.

This cost doesn’t care about usage. It cares about scope.

And because it isn’t directly tied to queries, it’s often excluded from pricing discussions, even though it belongs in your COGS model.

If your pricing doesn’t account for the fact that knowledge must be continuously refreshed and reshaped, you are subsidizing every future feature you add.

2.2 Layer 2: Retrieval and memory access

Retrieval is often introduced as a quality improvement, not a cost driver. That’s why it’s frequently mispriced.

Every retrieval operation has a cost: vector searches, ranking, filtering, post-processing, and latency overhead.

But the real cost isn’t the retrieval call itself. It’s what happens when retrieval is sloppy.

Poor retrieval design pulls too much information “just in case.” That extra context flows downstream into the model, inflating context length, increasing inference cost, and slowing responses.

In other words, retrieval mistakes don’t just cost money once. They amplify cost everywhere else.

Teams justify this with “better safe than sorry.” Economically, that mindset is disastrous.

Pricing models that don’t account for retrieval discipline reward inefficiency. You don’t see the cost, so you trigger workflows that retrieve far more than you need.

The system absorbs it until it can’t.

2.3 Layer 3: Context construction

Context is where AI systems quietly bleed money.

Every extra paragraph added to context increases cost, latency, and variance. Context growth is subtle. A small instruction added here. A clarification added there. A “just in case” rule appended after an incident. None of these decisions feel expensive in isolation.

Six months later, you have a bloated prompt that costs five times what it did at launch, and nobody remembers why.

From a pricing perspective, this is critical: context is one of the cost drivers you directly control, yet it’s rarely treated as an economic decision.

Pricing that ignores context growth assumes the system will never evolve.

It always does.

2.4 Layer 4: Model execution

This is the layer everyone fixates on, and for good reason. Models are expensive, and choosing the wrong one at the wrong time can wipe out margins.

But the real mistake isn’t using large models. It’s using them by default.

In production systems, the correct model choice is almost never static. Some tasks require deep reasoning. Others require speed. Others require consistency.

Routing everything through the “best” model is a convenience decision disguised as a quality decision.

The economic cost of this laziness shows up slowly. Margins thin. Finance asks why. Engineering points to user demand. PMs argue quality. Everyone is technically correct, and the system still loses money.

Pricing that assumes a single model cost is fantasy pricing. Real AI pricing must assume dynamic routing, and it must be resilient to mistakes in that routing.

2.5 Layer 5: Orchestration and retries

Modern AI products are not single calls. They are workflows.

A single user action might trigger a planner, a worker, a validator, a formatter, and a fallback path if confidence is low. Each of these steps may call a model. Some may retry automatically. Others may escalate to a heavier model.

None of this is visible to you, which makes it easy to forget it exists when pricing.

But orchestration is where AI costs multiply silently. One user request becomes five or ten model calls. A single retry doubles cost instantly. A safety check adds latency and compute but no visible feature.

These costs are the result of good intentions: reliability, safety, quality. That’s why teams hesitate to price for them explicitly. But ignoring them doesn’t make them free. It just hides them until margins collapse.

Pricing that doesn’t fund orchestration complexity is effectively betting that reliability won’t matter.

It always does.

2.6 Layer 6: Parallelism and concurrency

If there is one layer that kills otherwise healthy AI businesses, it’s this one.

Parallelism is not about how many total requests you handle. It’s about how many you handle at the same time.

Ten users spread across an hour are cheap. Ten users hitting the system in the same second are expensive.

They force you to provision capacity for peak load, not average behavior. That capacity costs money whether it’s used or not.

This is why AI systems feel fine in testing and fall apart under success.

Early usage is staggered and forgiving. Real adoption is spiky, synchronized, and merciless.

Pricing that doesn’t account for concurrency implicitly promises infinite capacity. The system cannot deliver that promise without burning cash.

Capacity-aware pricing is not an enterprise luxury. It’s a survival mechanism.

2.7 Layer 7: Evaluation, monitoring, and guardrails

The final layer is the one serious teams can’t avoid.

If your AI system matters, you will pay to monitor it. If it touches money, decisions, customers, or risk, you will log outputs, evaluate quality, audit failures, and add guardrails.

These costs scale with importance, not usage. The more people rely on the system, the more you invest here. And unlike tokens, these costs don’t shrink when usage drops. They are structural.

Pricing models that pretend evaluation is “overhead” are lying to themselves. If your product requires trust, trust must be priced in.

2.8 Why these layers compound, not add

The most important thing to understand about the seven layers is that they interact.

A retrieval inefficiency inflates context. Inflated context increases inference cost. Higher inference cost encourages routing to smaller models, which increases error rates. Errors trigger retries. Retries increase concurrency pressure. Concurrency pressure forces overprovisioning. Overprovisioning raises baseline cost.

This is how AI costs spiral without any single decision looking “wrong.”

And this is why pricing must be conservative by design. You are not pricing a stable machine. You are pricing a living system that accumulates complexity over time.

2.9 What this means for pricing decisions

Once you see the full cost stack, one thing becomes clear: pricing must absorb uncertainty.

You cannot price AI assuming perfect efficiency, perfect routing, perfect retrieval, and perfect behavior. You must price assuming drift, mistakes, and growth in complexity.

The teams that survive are not the ones with the lowest per-token cost. They are the ones whose pricing models are resilient to the system getting messier over time.

If your pricing only works when everything goes right, it doesn’t work.

Share

3. The Four AI Product Pricing Models (and When to Use Each)

Once you accept AI pricing can’t be treated like SaaS pricing, the next mistake is over-engineering the solution.

Teams invent exotic hybrids, clever credit systems, abstract “AI units,” or opaque bundles that look smart on a slide but collapse the moment real users touch the product.

In practice, AI products converge to four pricing models that survive real usage.

What matters is not creativity. What matters is whether the pricing model maps cleanly to how cost is generated inside your system, and whether it nudges users toward behavior your system can afford.

3.1 Usage-based pricing: honest, brutal, and often misused

Usage-based pricing is the most straightforward model: users pay for what they consume. Tokens, queries, compute units, requests… pick your unit.

This model feels “right” to engineers and finance teams because it aligns cleanly with marginal cost. Every extra unit of usage produces revenue. Every spike in cost is theoretically covered.

The problem is that users are not economists.

In practice, usage pricing introduces something that kills many AI products before they reach maturity: meter anxiety. The moment users feel like every interaction is ticking a meter, they subconsciously pull back. They stop experimenting. They avoid edge cases. They use the product less precisely when they should be discovering where the value actually lies.

This is why usage pricing works best in environments where users already expect it. Developer tools. APIs. Infrastructure. Places where buyers think in throughput, budgets, and efficiency. In those contexts, usage pricing is not scary; it’s familiar.

But when teams apply usage pricing to productivity tools, consumer products, or exploratory workflows, adoption stalls. Users don’t want to think about cost while they’re still learning what the product can do.

There’s another subtle risk: usage pricing assumes users can control cost drivers. In AI systems, they often can’t. A user might submit the same request twice and get two radically different internal cost profiles because one path triggered retries or heavier models.

From the user’s perspective, that feels unfair, even if it’s economically justified.

Usage pricing works when:

• you understand what drives cost

• the system behaves predictably

• you are comfortable optimizing usage

If any of those fail, usage pricing becomes a growth ceiling, not a revenue lever.

Example: OpenAI API

OpenAI prices its API based on input and output tokens. The more tokens you send and receive, the more you pay. This is the clearest and most widely accepted example of usage-based pricing in AI. Nearly every major AI API provider follows this same principle.

3.2 Hybrid pricing: predictability for you, protection for the business

Hybrid pricing exists because pure usage pricing is too harsh for most real-world products.

In a hybrid model, users pay a base subscription that includes a reasonable amount of usage, with overages kicking in once they exceed that baseline. Psychologically, this creates safety. Economically, it creates a buffer.

This is the most common and most misunderstood AI pricing model.

The strength of hybrid pricing is that it decouples exploration from punishment. Users can play, learn, and build habits without watching a meter, while the business retains the ability to capture revenue from heavy or expensive usage.

But hybrid pricing fails when teams treat it as a generosity exercise instead of a control system.

The included usage must reflect what the system can handle sustainably for the median user, not what looks attractive on a pricing page. Over-including usage trains users to behave expensively, and once that behavior is learned, clawing it back is painful.

Another common mistake is hiding overage mechanics. Teams worry that showing overage pricing will scare users, so they bury it or avoid it altogether. This backfires later when costs spike and pricing has to change abruptly.

Done well, hybrid pricing creates a quiet but powerful dynamic: most users stay comfortably within the base tier, while a minority of heavy users fund the variance for everyone else. Done poorly, it subsidizes your most expensive customers indefinitely.

Hybrid pricing is ideal when:

• users need freedom to explore

• costs vary widely across users

• you want predictable revenue without unlimited exposure

Example: Notion AI

Notion AI is bundled into a subscription that includes a fixed allocation of AI credits. Once users exceed those credits, they must purchase additional credits or upgrade to a higher plan. This is a classic example of hybrid pricing — subscription first, usage second.

3.3 Outcome-based pricing: alignment at a cost

Outcome-based pricing is the model everyone talks about and few teams can sustain.

Instead of paying for usage, you pay for results: a ticket resolved, a lead qualified, a document processed correctly.

From your perspective, this is perfect. You don’t care how the AI works. You care if it delivers value.

From a system perspective, it is unforgiving.

Outcome pricing only works if teams can:

• define outcomes unambiguously

• measure them reliably

• deliver consistently

• absorb failures without destroying margins

Most AI systems aren’t stable enough for this early. When outcomes are priced, every failure becomes a revenue problem.

This forces heavy investment in evaluation, monitoring, and often human-in-the-loop.

There’s also a psychological trap: when users only pay for success, they push the system harder. They retry more. They test boundaries. That behavior increases cost even when revenue stays flat.

Outcome pricing works best when:

• the task is narrow and well-defined

• the value of success is high

• the system is mature enough that reliability is not a question

For early-stage AI products, outcome pricing is often aspirational. It becomes viable later, once reliability is no longer a question.

Example: Enterprise AI Automation & Copilot-Style Agents

In enterprise environments, companies (including Microsoft through its evolving Copilot strategy) are increasingly exploring pricing based on work performed by AI agents, rather than raw token usage. Satya shared this in a podcast with Dwarkesh.

This moves pricing closer to outcome-aligned models, where customers pay for completed tasks or delivered value.

3.4 Capacity-based pricing: selling availability, not usage

Capacity-based pricing is underused despite mapping well to how AI systems fail.

Instead of paying for how much you consume, you pay for how much capacity you reserve: concurrency limits, throughput guarantees, response-time SLAs, parallel workflows.

This model recognizes a truth: many AI costs are driven not by total volume, but by peak demand.

If ten customers hit the system at once, the business pays for that concurrency whether you use it continuously or not. Capacity pricing monetizes that reality.

From the customer’s perspective, this model makes sense in enterprise and mission-critical contexts. They don’t want “cheap.” They want reliable. They are willing to pay to know the system will respond when needed.

The challenge is that capacity pricing requires operational maturity. You must actually be able to enforce limits, manage queues, and honor guarantees. You can’t fake it.

Capacity pricing works best when:

• latency matters

• concurrency drives cost

• you value reliability over raw usage

• workloads are predictable in bursts

It is rarely the first pricing model a company adopts, but it is often the one that unlocks sustainable scale.

Example: GPU / AI Compute Marketplaces

Platforms like SF Compute allow organizations to buy or reserve compute capacity, such as GPU time, instead of paying per request. This reflects capacity-based pricing, where customers pay for guaranteed availability and peak throughput rather than average usage.

3.5 The real mistake: choosing based on fashion, not physics

What kills pricing strategies isn’t picking the “wrong” model. It’s picking a model that doesn’t match the physics of your system.

If costs spike with concurrency but pricing is purely usage-based, you lose money under success.

If costs vary wildly by task complexity but pricing is per seat, heavy users destroy margins.

If the system is unstable but pricing is per outcome, reliability costs overwhelm revenue.

Pricing models are economic constraints. They must reflect how your system behaves, not how you wish it behaved.

3.6 The rule you learn in postmortems

If your pricing model doesn’t get stricter as usage grows, your margins will get worse as success grows.

Every viable AI pricing model tightens constraints as demand increases. It charges more, limits capacity, enforces overages, or demands higher commitment.

If pricing only encourages more usage without increasing discipline, it isn’t pricing. It’s a subsidy that increases your problems.

Side Note: Pricing is system design. You can’t do it well without understanding how AI products actually work.

If you want to learn that end to end, here’s the program I recommend: AI Product Management Certification (with Miqdad Jaffer, Product Lead at OpenAI). I lead the AI Builds Lab and run 3 live sessions in the cohort.

Next cohort: January 26, 2026. $500 off for our community:

Claim $500 off

Continue Reading

Up to here, you’ve got the foundation for AI product pricing (3,800+ words):

• why AI pricing is different from SaaS

• the 7-layer cost stack (and why the layers compound)

• the 4 pricing models that survive real usage

• the rule you learn in postmortems

If you want the practical part, the rest (4,200+ words) goes deeper into:

• stability vs scale, and how premium tiers are really “stability budgets”

• a decision tree you can apply to your product

• an AI P&L breakdown (including peak behavior and concurrency, even when you use APIs)

• AI cost glossary

If this helped, forward sections 2 and 3 to your product and engineering leaders. It’s the fastest way to get aligned before you ship pricing.

Share

Read more