From drafting for you to handing you a finished artifact

Personal leverage is the most common use case for everyone: writing docs, doing research, building small artifacts. The difference between Rung 1 and Rung 2 comes down to one sentence — at Rung 1, AI gives you text and you still have to copy-paste and organize it yourself; at Rung 2, AI hands you something usable directly.

Rung 1: AI writes text for you

You have AI help write a PRD, a Jira ticket, or an email, then copy-paste the answer into some other tool. Most people stop at this rung. The author's example is asking Claude to help write a PRD: the AI has almost no context on your company or on what makes a good PRD, so you go back and forth until it's "good enough," then paste it into Google Docs or Word and polish it before you dare send it to the team.

Rung 1: having Claude draft a PRD — the output still has to be copied into a doc and polished by hand. Source: Colin Matthews / Lenny's Newsletter

Rung 2: AI produces the artifact directly

At this rung, AI actually "does the work" and produces something real — a slide deck, an Excel model, a small prototype. The author's example is having Claude build a cost-comparison model: building and self-hosting an agent versus using a managed service like Vercel, and how much each would cost. Here's the exact prompt he used at the time — copy it and adapt it to your own scenario.

Create a model that represents costs if we build and host ourselves vs. using managed agents. Do research on the engineering time saved and the compute costs in self-hosted vs. managed. Look at other vendors, like Cloudflare, Vercel, or E2B that provide sandboxes for agents for pricing. Demonstrate both the cost of the pilot and the cost at scale in the model, assuming we have 5M+ agent instances running annually (where an agent instance is per hour).

The cost model produced by the prompt above: costs for both the pilot stage and at-scale stage. Source: Colin Matthews / Lenny's Newsletter

The author's caveat: output at this rung still needs heavy editing, but it's already a step beyond "copying text from AI into another document" — AI hands you an artifact now, not just a block of text waiting to be edited.

Connect AI to real tools and let it finish the whole job itself

This is the top rung of personal leverage, and the first key point of the whole piece: connect the tools you use every day to AI via MCP, and it can pull data and research on its own, finishing end to end a task you used to hand off to a colleague. There's only one key move: connect AI to your real tools.

How to connect: Claude Code, Codex, and Cursor can all connect to tools like Figma, Amplitude, PostHog, and Pendo via MCP. It's simple — just go to your product's connector marketplace and add the tool (Claude, ChatGPT, Gemini), and it's a one-time setup that stays on forever — you never have to touch it again.

Add your everyday tools in the product's connector marketplace — a one-time setup that stays on forever. Source: Colin Matthews / Lenny's Newsletter

Example: Connect Claude to PostHog and let it run a retention analysis on its own

The author uses a fictional product, Stride (a Strava-clone fitness app), as an example. He wants to run a retention analysis: do users who use the social-sharing feature have higher 30-day retention than those who don't? He connected Claude to PostHog, the product analytics tool, and had it run the whole analysis and produce a report with a single prompt.

Use PostHog to check if users who use social share features have a higher 30d retention than those who don't. Show me an html doc as a final output visualizing cohorts and any other useful data. Cite all your sources so I can validate.

The retention analysis produced by the prompt above: visualizes the retention gap between the two user groups, with traceable data sources. Source: Colin Matthews / Lenny's Newsletter

The author stresses that the line cite your sources in the prompt is critical: with it, you can easily verify whether the results are correct. In this example, Claude gave direct links pointing back to the raw data in PostHog.

Once you have access, what to practice first

Once your tools are connected, the author suggests picking a routine task to practice on. Below are four high-leverage tasks he suggests you can try right away, listed here verbatim.

- Analyzing how a launch went by reviewing recent customer tickets and online sentiment
- Checking how many users actually use a feature through product analytics events
- Summarizing a recording from a customer call and creating a prototype based on their feedback
- Updating your next sprint based on a change in roadmap priorities

The results will probably disappoint you at first — that's just because the model doesn't yet know your standards. Keep iterating with it until you're satisfied, then, in that same conversation, have AI turn this workflow into a skill and lock it in place, so you can reuse it with one click next time. This process can give you a decent first draft of almost anything: PRDs, roadmaps, marketing materials, research analyses, prototypes, Figma files.

Web prototypes validate ideas fast — but the code is a dead end

Product leverage covers the gap between "what you want to build" and "what you can ship." Rung 1 is quickly building a prototype with web prototyping tools (Lovable, Replit, Magic Patterns) — it conveys your idea better than a doc, but it has a hard limit: the generated code has nothing to do with your product's real codebase.

Back to the Stride example. Below is its current profile page — users keep complaining that the cancel-subscription path is unclear, and once the free trial ends, they can't tell what their subscription status even is.

Stride's current profile page: the cancel-subscription path is unclear and draws frequent complaints. Source: Colin Matthews / Lenny's Newsletter

You can use an AI web prototyping tool to quickly mock up a change and test with users and stakeholders whether your approach actually solves the problem. The animation below is a cancel-subscription flow built with a web prototyping tool.

Demo: a cancel-subscription mockup built with a web prototyping tool (Lovable / Replit / Magic Patterns), used to quickly test the approach. Source: Colin Matthews / Lenny's Newsletter

Web prototyping tools have limited knowledge of your real components and data model, so what they produce is far from reality — turning a tested prototype into real code still takes another round of work. Which brings us to the next rung.

Let AI edit directly inside your real codebase

Rung 2 is the second key point of the piece: use Claude Code or Codex to read your product's real codebase directly and prototype from it, instead of relying on screenshots or elaborate prompts. The resulting UI uses real components and follows the real design system, putting it much closer to shippable code.

Same Stride cancel-subscription example, but this time Claude Code / Codex works from the existing codebase. The change is added directly to the real settings page, reuses real components, and follows the product's own design system. The animation below shows the result of the codebase prototype.

Demo: a cancel-subscription flow built by Claude Code / Codex in the real codebase, added into the real settings page and reusing real components. Source: Colin Matthews / Lenny's Newsletter

This rung doesn't require running the whole product on your laptop, nor expert-level coding skill, but it does need a bit of technical grounding: first, using Claude Code or Codex to write code and run the app; second, you need a codebase that contains only the UI, without a full backend. Where does that codebase come from? Have an engineer run the prompt below against the main codebase for you.

Create a new repo that contains all of the base UI elements, styles, routes, pages, and components for [list parts of the product you want included]. Create a mock data store that mimics the API data model and is stored locally. I should be able to run the resulting repo without any environment variables or backend services.

Once it's built, clone the new repo to your computer and you'll have a UI version that's easy to run and won't accidentally break the real product. Engineers will sometimes tell you this is more complicated than a single prompt, but prototyping on your real styles and components is worth it — the author's advice is to find a way over that hurdle.

Let the agent turn changes into a mergeable PR directly

The top rung of product leverage is having the agent submit code straight to production: an engineer takes over the PR, reviews it, and merges it into the product. This rung is the biggest test of a PM's technical judgment — you need to know which changes you can safely let AI submit as a PR, and which ones you should back off from.

The author's example: your billing change might only touch the UI, with the backend APIs, data, and events already in place — that's a good fit for submitting a PR directly. But the change might also require building new infrastructure, or integrating with another team, in which case you shouldn't take it on yourself. The criteria are below.

As a PM, there's no point spending your time "being a worse engineer than the engineers on your team." Knowing when to write a doc, when to prototype, and when to submit a PR matters just as much as being able to actually do those tasks.

As a PM, there's no point spending your time being a worse engineer than everyone else on the team.Colin Matthews / Lenny's Newsletter

The third ladder — the original only leaves us its name

The framework defines three types of leverage at the outset; the third is systems leverage — turning your AI usage into repeatable steps so you can keep outsourcing work to AI and consistently get high-quality results. But in the body of the piece, it never gets the three-rung breakdown and hands-on examples the first two ladders receive.

The author drops a hint in the personal-leverage section: the first draft's quality might not be perfect, "we'll come back to that when we get to systems leverage." By the end of the piece, this ladder stays at the concept level — that's where the source material ends. It reads more like a direction the author might develop in a future course or article; we're reporting that honestly here rather than filling in the gap for him.

The first step you can take today

Instead of agonizing over the whole framework, just take one action first. Figure out which rung you're on for each of the two ladders, then pick one move you haven't tried yet and give it a shot.

1. Look at the 3×3 matrix above and mark which rung you're currently on for personal leverage and for product leverage.
2. Go to the connector marketplace (Claude / ChatGPT / Gemini) and connect a tool you use often, like PostHog or Notion — a one-time setup that stays on forever.
3. Pick one item from the task list in Section 3 of this piece to practice on — like "check how many users are actually using a given feature."
4. If you're not happy with the result, keep iterating on the prompt; once you are, in that same conversation have AI summarize the workflow into a skill and lock it in as a reusable step.

Which rung fits best depends on how deep the task at hand should actually use AI.Colin Matthews / Lenny's Newsletter

The author maps how PMs use AI onto three "leverage ladders," measuring how deep you take your AI usage: the higher up, the more AI completes for you, leaving you just to review. This piece fully covers two of them: personal leverage (your own work) and product leverage (what you ship); the third, systems leverage, is only named (see the end). Below, we use "XiaoHu producing a retention analysis report" to see how the three rungs of personal leverage actually differ.

Climbing the ladder comes down to two key moves. First, connect the tools you use every day to AI via MCP (Model Context Protocol — a standard interface that lets AI read and write data in external tools directly), like giving it a master key: it can walk into PostHog (a product analytics tool) and grab data itself, and you stop being the courier. Just click to add it in Claude / ChatGPT / Gemini's connector marketplace — a one-time setup that stays on forever.

Second, when prototyping (a clickable UI sample), have AI read your product's real code directly instead of starting from scratch:

What do you actually save by climbing? Back to that retention report. You used to squeeze it in between two meetings yourself, or wait in line for a data teammate; now, one prompt to an AI with tools connected, and minutes later you have a report with cited sources you can click back to verify.

Note: the claims of training 30,000+ PMs and shipping 10+ products are the author's own account and the Lenny's Newsletter editor's introduction, with no third-party verification; the framework's third ladder, "systems leverage," is only named at the outset in the original — the body never gives it the same treatment as the first two.