DEV Community: Daniel Marin

How I Wired Claude Into n8n to Auto-Summarize Every PDF That Hits My Inbox

Daniel Marin — Fri, 08 May 2026 12:07:29 +0000

A step-by-step guide to using the Anthropic and readPDF nodes in n8n, with full importable workflow JSON.

Here's the quick version: to use Claude in an n8n workflow, add an n8n-nodes-base.anthropic node and set your Anthropic API key as a credential. To extract text from PDFs before sending to Claude, chain an n8n-nodes-base.readpdf node first. Its text output becomes the prompt input for Claude.

The two nodes together cover the most common n8n + Claude pattern: ingest a document, extract its text, then have Claude summarize, classify, or answer questions about it. All without writing code.

Why These Two Nodes Together?

n8n ships native integrations for both Anthropic and PDF reading, and they compose naturally. The readPDF node handles binary-to-text conversion. The Anthropic node handles the API call. You connect them with a single wire and the workflow does the rest.

This combination unlocks a large class of document-processing automations that previously required Python scripts or dedicated document-intelligence SaaS tools:

Summarize incoming contracts or invoices the moment they land in a shared inbox
Classify uploaded research papers by topic and route them to the right Notion database
Extract structured data from PDF reports and write the results to a Google Sheet
Answer questions about a PDF using Claude, then post the answer to Slack

Setting Up the Anthropic Node

The Anthropic node is bundled in n8n's standard node library. No extra install needed. It supports Text and Chat operations and maps directly to the Anthropic Messages API.

Step 1: Add credentials. Go to Settings, then Credentials, then New. Search for "Anthropic" and paste your API key. The credential type is simply "Anthropic API," one field.

Step 2: Configure the node. In the node editor, the key fields are:

resource / operation: Set resource to text and operation to complete for a single-turn call, or use chat / sendMessage for a conversational flow.

model: The model ID string, for example claude-sonnet-4-6 or claude-haiku-4-5-20251001. Use Haiku for high-volume document classification. Use Sonnet for extraction and reasoning tasks.

prompt (Text operation) or messages (Chat operation): Reference the upstream node output here using an expression, for example {{ $json.text }} when chaining after a readPDF node.

maxTokensToSample: Cap the response length. 1024 is a safe default for summaries. Bump to 4096 for structured extraction where you need complete JSON output.

Minimal workflow JSON (Anthropic node only)

Import this via Workflows, then Import from JSON:

{
  "nodes": [
    {
      "parameters": {
        "prompt": "Summarize the following text in three bullet points:\n\n{{ $json.body }}"
      },
      "type": "n8n-nodes-base.anthropic",
      "typeVersion": 1,
      "position": [460, 300],
      "name": "Claude – Summarize",
      "credentials": {
        "anthropicApi": {
          "name": "Anthropic API"
        }
      }
    }
  ]
}

The "type": "n8n-nodes-base.anthropic" field is how n8n identifies the node internally. You'll see this string in exported workflow JSON whenever the Anthropic node appears.

Reading PDFs Before Sending to Claude

The n8n-nodes-base.readpdf node converts a binary PDF attachment into plain text. It has no configuration options. You pass it a binary item and it outputs a text field. That text field is what you reference in the Anthropic node's prompt expression.

Where the binary comes from. The most common upstream nodes that produce PDF binary data are:

Gmail / Outlook: attachment extraction from incoming emails
HTTP Request: fetching a PDF from a URL, with response format set to file
Google Drive / Dropbox: downloading a file by ID
Webhook: receiving a multipart/form-data upload

In all cases, the binary field is typically called data. The readPDF node picks this up automatically unless you override the binary property name.

The readPDF node in workflow JSON

{
  "parameters": {
    "options": {}
  },
  "type": "n8n-nodes-base.readpdf",
  "typeVersion": 1,
  "position": [240, 300],
  "name": "Extract PDF Text"
}

No required parameter beyond the node type itself. The node reads whatever binary is in the input item's data property and writes the extracted text to $json.text on the output item.

Full Workflow: PDF to Claude to Slack

Here is a complete, importable n8n workflow JSON that watches a Gmail inbox for PDF attachments, extracts their text, sends the text to Claude for summarization, and posts the summary to Slack.

{
  "name": "PDF Summarizer via Claude",
  "nodes": [
    {
      "parameters": {
        "pollTimes": { "item": [{ "mode": "everyMinute" }] },
        "filters": { "readStatus": "unread" },
        "downloadAttachments": true
      },
      "type": "n8n-nodes-base.gmailTrigger",
      "typeVersion": 1,
      "position": [0, 300],
      "name": "Gmail – New Email with Attachment"
    },
    {
      "parameters": {
        "conditions": {
          "string": [{
            "value1": "={{ $binary.data.mimeType }}",
            "operation": "contains",
            "value2": "pdf"
          }]
        }
      },
      "type": "n8n-nodes-base.if",
      "typeVersion": 1,
      "position": [220, 300],
      "name": "Is PDF?"
    },
    {
      "parameters": { "options": {} },
      "type": "n8n-nodes-base.readpdf",
      "typeVersion": 1,
      "position": [440, 240],
      "name": "Extract PDF Text"
    },
    {
      "parameters": {
        "model": "claude-haiku-4-5-20251001",
        "prompt": "Summarize the following document in 3-5 bullet points. Be concise and focus on the key facts.\n\n{{ $json.text }}",
        "maxTokensToSample": 1024
      },
      "type": "n8n-nodes-base.anthropic",
      "typeVersion": 1,
      "position": [660, 240],
      "name": "Claude – Summarize PDF",
      "credentials": {
        "anthropicApi": { "name": "Anthropic API" }
      }
    },
    {
      "parameters": {
        "channel": "#document-summaries",
        "text": "=*New PDF summary:*\n{{ $json.completion }}"
      },
      "type": "n8n-nodes-base.slack",
      "typeVersion": 2,
      "position": [880, 240],
      "name": "Post to Slack"
    }
  ],
  "connections": {
    "Gmail – New Email with Attachment": {
      "main": [[{ "node": "Is PDF?", "type": "main", "index": 0 }]]
    },
    "Is PDF?": {
      "main": [[{ "node": "Extract PDF Text", "type": "main", "index": 0 }]]
    },
    "Extract PDF Text": {
      "main": [[{ "node": "Claude – Summarize PDF", "type": "main", "index": 0 }]]
    },
    "Claude – Summarize PDF": {
      "main": [[{ "node": "Post to Slack", "type": "main", "index": 0 }]]
    }
  }
}

Key things to observe:

The readPDF output is accessed via {{ $json.text }} in the Anthropic node's prompt
Claude's response is in {{ $json.completion }} for the Text operation (or {{ $json.content[0].text }} for the Chat operation)
Claude Haiku is used here for cost efficiency. Swap to Sonnet for complex extraction

Structured Extraction: Getting JSON Out of Claude

For workflows that need to write data to a spreadsheet or database, you want Claude to return structured JSON rather than prose. Here's the prompt pattern that works reliably:

Extract the following fields from the invoice text and return ONLY valid JSON.
Do not include markdown code fences. Do not include any explanation.

Fields to extract:
- invoice_number (string)
- vendor_name (string)
- total_amount (number)
- due_date (ISO 8601 date string)
- line_items (array of { description, quantity, unit_price, total })

Invoice text:
{{ $json.text }}

After the Anthropic node, add a Code node to parse the output:

// Code node — parse Claude's JSON response
const raw = $input.first().json.completion;
const parsed = JSON.parse(raw.trim());
return [{ json: parsed }];

The parsed object then flows downstream as normal n8n item data, ready to map into a Google Sheets row, an Airtable record, or a database insert.

Handling Long PDFs (Token Limits)

Claude Haiku and Sonnet both support up to 200k input tokens. Most PDFs fall well within that limit. However, n8n-nodes-base.readpdf extracts all text at once. For very long documents (500+ pages), you may want to truncate or chunk the text before passing it to Claude.

Add a Code node between readPDF and the Anthropic node to cap the input:

// Truncate to first ~100k characters (~75k tokens)
const MAX_CHARS = 100_000;
const text = $input.first().json.text ?? '';
return [{ json: { text: text.slice(0, MAX_CHARS) } }];

For genuine multi-part documents, consider a map/loop pattern: split the text into overlapping chunks, run Claude on each, then combine the results with a final merge-and-consolidate call.

Common Errors and Fixes

readPDF: "No binary data found in item." The upstream node didn't pass a binary field named data. Check the binary property name in the previous node (Gmail attachment might name it attachment_0). Open the node output panel, click the binary tab, and copy the exact field name, then set it in readPDF's "Binary Property" option.

Anthropic: "Authentication failed." Your Anthropic credential is missing or the API key is wrong. Go to Settings, then Credentials, find the Anthropic credential, and re-enter the key from console.anthropic.com.

Anthropic: Empty completion or content field. This usually means maxTokensToSample was too low, or the prompt expression resolved to an empty string. Check that {{ $json.text }} is non-empty in the previous node's output before the Anthropic node fires. Add an IF node to skip items where text.length === 0.

JSON.parse fails on Claude's structured extraction output. Claude occasionally wraps JSON in markdown code fences even when told not to. Add a cleanup step before parsing:

const raw = $input.first().json.completion
  .replace(/^```
{% endraw %}
json\n?/i, '')
  .replace(/
{% raw %}
```$/, '')
  .trim();
const parsed = JSON.parse(raw);

Going Further

The readPDF to Anthropic chain is one pattern. The broader playbook for n8n + Claude automation covers webhook triggers, scheduled document processing, multi-step reasoning chains, and memory across workflow runs.

I publish detailed playbooks for n8n workflow building and API integration at claudecodehq.com. If you want to go further with Claude in agentic pipelines (tool use, multi-step reasoning, or building your own Claude-powered integrations beyond n8n), the MCP servers guide and AI agent walkthrough on the site cover those patterns in depth.

Originally published on claudecodehq.com

I Set Up 5 AI Writing Skills and Got My Publishing Cadence Back. Here's How.

Daniel Marin — Wed, 06 May 2026 18:44:09 +0000

Five Claude Skills that handle the parts of writing that eat your time without touching the parts that require your voice: ideation, drafting, distribution, cleanup, and fiction continuity.

The writing itself is rarely the bottleneck. It's everything around it: evaluating which idea to write next, building the SEO outline, drafting the distribution package after you publish, repurposing a newsletter into social posts, cleaning up the AI-isms that crept into a draft, making sure your novel's character descriptions are consistent across 300 pages.

Writers lose hours every week to tasks that are necessary but not the thing they actually want to be doing.

Claude writing skills (pre-built instruction sets that tell Claude exactly how to behave for a specific writing task) are the clearest productivity win for writers who use AI. You set up the skill once (five to ten minutes, no coding), and from then on Claude handles the mechanical work so you can stay in the creative layer.

Here are the five skills that address the most common writer bottlenecks.

1. Article Pipeline: From Idea to Published Draft

Most writers have more ideas than published articles. The gap isn't creativity. It's the process of moving an idea from "scribble in notes app" to "worth writing" to "outlined" to "drafted." Each transition has friction, and that friction compounds: you never know which idea to prioritize, so you either churn on your strongest topic or pick arbitrarily and feel vaguely guilty about the rest.

An article pipeline skill is a structured system for that exact process. Feed it a list of ideas (rough, half-formed, even contradictory) and it scores each one for audience fit and SEO potential. The winner gets a detailed outline with keyword strategy built in. Then a polished first draft, saved as a file you can open and edit immediately. The whole thing, from idea list to draft, in a single session.

"Here are 12 ideas I've been sitting on. Score them by how strong the angle is for my audience (indie SaaS founders) and SEO opportunity. Write the top one as a full 1,500-word draft with a keyword strategy, and give me the outlines for the runner-up two so I can work on them next."

The key discipline this skill instills: you stop treating every idea as equally worth writing and start making evidence-based calls about which ones to actually publish. The backlog of ideas stops being a source of guilt and becomes a prioritized queue.

Before: 15 ideas in a notes app. You pick one more or less at random, spend two hours on an outline, realize the angle isn't strong enough, abandon it, and feel stuck.

After: 15 ideas scored. One clear winner with a draft. Two runner-ups with outlines. Publishing cadence: one post per week for three weeks from a single session.

Setup: 5 minutes. Best for: bloggers, newsletter authors, freelancers, developer advocates.

2. Blog Post Writer: Draft, Title, Thread, and Teaser in One Prompt

Publishing a blog post is a two-part job: writing it and distributing it. Most writers are good at the first part and exhausted by the second. After you finish the draft, you still need five title options to A/B test, a social thread that repackages the key points as standalone value, an email teaser that drives clicks, and CTA variants to test at the end. By the time the post is written, all of that feels like a second writing session, so it either gets done badly or not at all.

A blog post writer skill collapses the whole package into a single prompt. Describe your topic, your angle, and your audience. It produces: five title options, an SEO-structured outline, a polished 1,800-word draft, an X thread version, an email teaser, and three CTA variants. All formatted and ready to use.

"Write a blog post about why most SaaS onboarding flows fail at the activation step. Audience: product managers at B2B SaaS companies. Conversational but authoritative tone. Include a stat-heavy section on activation benchmarks."

The output isn't a starting point. It's a near-final draft. The skill is built by writers who do this work daily, which means the defaults are already calibrated: intro hooks that earn the reader's attention, sections that build on each other logically, conclusions that close with action rather than trailing off. You edit the 10 to 20% that's yours. Claude writes the 80% that's structural.

Setup: 5 minutes. Best for: content marketing, solo bloggers, founders doing thought leadership.

3. Content Repurposer: One Newsletter, Two Weeks of Social Posts

The economics of content distribution are brutal for writers who work alone. You spend four hours on a newsletter, publish it, it gets a decent open rate, and then it disappears. That same piece could live as six X threads and six LinkedIn posts over the next two weeks. But rewriting a newsletter for two platforms, in two different formats, takes nearly as long as writing it in the first place. So you don't. The content dies after one use.

A content repurposer skill handles the translation layer automatically. Feed it a piece of long-form content (newsletter, podcast transcript, article, video script) and it produces platform-native posts in the right format for X and LinkedIn. X threads that distill the key argument into punchy, standalone points. LinkedIn posts with the professional framing and whitespace that performs there. Output saved to a folder, ready to schedule.

"Repurpose this week's newsletter into social content. X audience: indie hackers and builders. LinkedIn audience: senior product and marketing managers. I want 6 X threads and 6 LinkedIn posts, each one standalone, not a teaser. Prioritize the most counterintuitive points from the piece."

The distinction that makes this skill work well is the "platform-native" framing. A LinkedIn post isn't a trimmed X thread. An X thread isn't a paragraph broken into tweets. The skill understands the format differences (length, tone, how the hook works, what kind of ending performs) and writes for each platform as its own medium.

Setup: 10 minutes. Best for: newsletter authors, podcast hosts, solo creators, content teams.

4. AI Writing Pattern Remover: Make AI-Assisted Drafts Sound Human

If you use AI to help draft content, you already know the problem. The draft is structurally sound, the ideas are correct, the length is right. But it reads like AI wrote it. Not because of any single word, but because of patterns: the uniform paragraph lengths, the tendency to start every section with "In today's world...", the rule-of-three structure that repeats through every single point, the vocabulary tics ("delve," "leverage," "robust") that appear so often in AI output they've become tells.

Readers notice this, often before they can articulate why. AI detection tools notice it too.

An AI pattern remover skill audits drafts specifically for these structural and vocabulary patterns, flags every instance with an explanation of why it reads as AI-generated, and rewrites the content to preserve your ideas while stripping the tells. You get a diff summary of what changed and why, so you learn the patterns rather than just getting a cleaner draft each time.

"Audit this article for AI writing patterns. Flag vocabulary tells, structural patterns (uniform paragraph lengths, rule-of-three), and formatting habits. Then rewrite it to preserve the argument but sound like a specific human voice: direct, slightly informal, no throat-clearing."

This skill is most valuable as the last step before publishing AI-assisted drafts. But it's also useful as a diagnostic on your own writing. Many writers have unconsciously absorbed AI patterns from reading too much generated content. The audit helps you identify and break them regardless of where the draft came from.

Setup: 5 minutes. Best for: content marketers, bloggers using AI drafts, comms teams, freelancers.

5. Book Bible: Keep Your Novel Consistent Across 300 Pages

Continuity errors are the silent draft-killers. Your protagonist's eyes change color between chapters. A character who was described as 5'10" on page 40 is suddenly looking up at someone in a scene where they should be looking down. A location established as east of the city is later approached from the east. The timeline doesn't add up when you try to calculate how many days have passed.

Your beta reader catches all of it. You missed all of it, because you were focused on the scene you were writing, not the thirty details you established fifty chapters ago.

A book bible skill creates and maintains a living reference document for your fiction, tracking character descriptions, relationship maps, timelines, location details, and world rules. Before you write a new scene, you ask Claude to check for consistency with existing material. It reads your manuscript against the bible and flags any contradictions with exact chapter references.

"I'm about to write Chapter 22. Check my manuscript for any continuity issues I should know about: character descriptions, timeline, and location consistency. Also check whether Marcus's injury from Chapter 8 should still be affecting him in this scene, given how much time has passed."

The skill pays for itself most clearly during revision, when you realize you need to change something established early in the book and need to find every downstream reference. A bible that's been maintained through drafting means that find-and-fix takes an hour instead of a week. It's the infrastructure decision that's always obvious in retrospect, never obvious when you're in the middle of drafting.

Setup: 10 minutes. Best for: novelists, screenwriters, series authors, NaNoWriMo participants.

The Writer's Workflow: How These Skills Fit Together

These five skills aren't meant to replace your writing. They're meant to surround it. The pattern that works for most writers looks like this:

Article Pipeline: decide what to write next from your idea backlog. Score, outline, draft. End of session: one published-quality draft and two ready-to-write outlines.
Blog Post Writer: when you need the full distribution package alongside the draft. Title tests, social thread, email teaser, CTAs. Everything to publish and promote in one go.
AI Writing Pattern Remover: final pass before publishing any AI-assisted draft. Strips the tells, preserves your voice.
Content Repurposer: after publishing, extend the life of the piece into two weeks of social content. One piece, multiple audiences, no rewriting.
Book Bible: parallel track for fiction writers. Running continuously in the background, keeping the manuscript honest as the draft grows.

You don't need all five at once. Start with the one that matches your current frustration, set it up (five to ten minutes), and use it on real work. The second skill setup is always faster than the first because the pattern is already familiar.

Getting Started

Writing is the part only you can do. The research, the structure, the angle, the voice: that's yours. The pipeline around it doesn't have to be.

I publish all five of these skills (and dozens more) as free, downloadable templates at claudecodehq.com. Each one is a single file you drop into a folder. No coding, no configuration, no subscription. Just the CLAUDE.md and you're working.

Originally published on claudecodehq.com

7 Claude Skills That Pay for Themselves in the First Week. No Coding Required.

Daniel Marin — Tue, 05 May 2026 17:15:48 +0000

Brand guidelines, contract review, budget analysis, ad copy, competitive intelligence, and more. Each one takes 10 minutes to set up and saves hours.

Running a small business means being the CEO, the marketer, the finance department, the legal reviewer, and the strategist, often in the same afternoon. You know which tasks are important. You also know which ones eat hours you don't have: writing the brand guide nobody's ever finished, reviewing that vendor contract that's been sitting in your inbox for a week, building the competitive analysis you promised yourself you'd do before Q2.

Claude Skills are pre-built instruction sets that turn Claude Code into a specialist for each of these jobs. You don't write code. You download a file, drop it in a folder, and ask Claude in plain English.

This guide covers the skills that have the highest return on the 5 to 15 minutes it takes to set each one up.

How to Use Any Skill in This List

Create a folder on your computer for that task (for example, ~/Documents/ContractReview)
Download the CLAUDE.md file and move it into that folder
Open Claude Code in that folder. It reads the skill automatically
Describe your task in plain English and get to work

No coding. No configuration. The folder is the on switch.

1. Brand Guidelines: Stop the "Which Blue Do We Use?" Question Forever

Ask any growing business when they last updated their brand guidelines. Most will laugh, or admit they've never had any. The result is inconsistency that erodes trust: four shades of your logo blue floating around in different decks, fonts that vary by whoever made the file, a tone of voice that depends on which team member wrote the email. Customers notice, even when they can't articulate why.

A brand guidelines skill produces a complete style guide from a single session. Describe your brand (colors you use, fonts, the feeling you want customers to have, what you're definitely not) and it outputs a proper document: hex codes for every color, typography rules with hierarchy, logo usage specifications, voice and tone guidelines with do's and don'ts, and visual examples showing what's on- and off-brand.

"Create brand guidelines for my bakery. Our colors are warm cream and terracotta. We want to feel artisanal and trustworthy, like a neighborhood institution, not a chain. We use Playfair Display for headings. Our voice is warm and knowledgeable, never trendy."

Once you have the document, every new hire, contractor, and freelancer gets the same brief. The "which blue?" question has a permanent answer. And when your brand evolves, you update the file and regenerate, rather than manually hunting down every outdated reference.

Setup: 10 minutes. Best for: any business onboarding contractors, producing content, or growing past one person.

2. Business Plan Generator: Investor-Ready in Hours, Not Weeks

Whether you're applying for an SBA loan, pitching to investors, joining an accelerator, or just trying to think clearly about your business, a well-structured plan matters. The problem isn't knowing your business. It's organizing it into the format that lenders and investors expect, with the right sections in the right depth. Most business owners either skip it or pay $2,000+ to have someone else write it.

A business plan skill takes what you know about your business and structures it into an investor-ready document: executive summary, market sizing (TAM/SAM/SOM), competitive positioning, financial projections (3-year model), go-to-market strategy, and operational plan. You provide the numbers and the vision. The skill provides the structure and the prose.

"Generate a business plan for my meal prep delivery startup. We're in Austin, targeting busy professionals aged 30 to 50. Current monthly revenue: $18K. We want to raise $200K to hire two drivers and expand to Dallas."

The output is a working draft, not a finished document. You'll refine the projections, tighten the language, and add specifics. But the structure is there, the sections are complete, and you're editing instead of writing from a blank page. That's the difference between a day of work and a week.

Setup: 10 minutes. Best for: loan applications, investor pitches, accelerator applications, strategic planning.

3. Contract Review: Catch the Landmines Before You Sign

Every small business owner has a story about a contract they signed without reading carefully enough. The auto-renewal clause that locked them in for another year. The liability provision that made them responsible for things they never agreed to verbally. The IP assignment buried in section 12 that handed over rights to work they created.

Hiring a lawyer to review every contract isn't realistic. Signing without reading is worse.

A contract review skill reads contracts the way a lawyer would on a first pass: clause by clause, flagging anything outside market norms with a severity rating (low, medium, high, critical), a plain-English explanation of why it matters, and a specific recommendation. Missing provisions are surfaced too. The output is a structured risk report you can act on immediately or hand to a lawyer with focused questions.

"Review this vendor services agreement. I'm the client. Flag any terms that are unusual, one-sided, or could create unexpected liability for me."

The skill doesn't replace legal advice on high-stakes contracts. But it means low- and medium-stakes agreements get a real review instead of a skim-and-hope. For a small business signing 5 to 10 contracts a month, this skill pays for itself on the first use.

Setup: 10 minutes. Best for: vendor agreements, client contracts, NDAs, SaaS subscriptions, lease agreements.

4. Budget Analyzer: Find Out Where Your Money Is Actually Going

"I know roughly what we spend" is one of the most expensive phrases in small business. Subscription creep is real: $19/month here, $49/month there, a tool somebody signed up for two years ago that nobody uses. Operating expenses that look fine in aggregate hide categories that are quietly out of control. Cash flow problems that feel sudden usually weren't. The pattern was there in the data for months.

A budget analyzer skill takes your bank statements or transaction exports and produces a clear picture: every transaction categorized, monthly spending by category, subscription and recurring charges itemized, and a budget built from actual patterns rather than wishful estimates.

"Analyze our last three months of business bank statements. Categorize every transaction, list every recurring charge, identify our three highest-spend categories, and flag any month-over-month increases greater than 20%."

Your financial data stays on your machine. Claude Code runs locally, so nothing leaves your computer. Run this skill monthly and you'll spot problems while they're still correctable instead of when they've compounded for a quarter.

Setup: 5 minutes. Best for: monthly financial review, finding subscription creep, cash flow visibility, budgeting.

5. Ad Copy Generator: Test More Angles Without Spending More Hours

Most small businesses run ads with a handful of copy variations, not because more wouldn't help, but because writing more takes time they don't have. The result is creative fatigue: audiences see the same ads too many times, performance drops, spend increases to compensate, and the cycle repeats. The answer isn't more budget. It's more creative.

An ad copy skill works in two modes: analysis and generation. Feed it your existing top-performing ads, and it identifies which hooks, CTAs, and formats are driving results. Then it generates 50+ new variations based on those proven patterns, for Facebook, Google, LinkedIn, or whatever platform you're running on. You go from a few tired ads to a full test queue without a copywriter or an agency.

"Here are our five best-performing Facebook ads from last quarter. Identify the patterns that make them work, then generate 20 new variations using the same hooks and CTA styles, but with fresh angles for a spring promotion."

Even without existing ads to analyze, you can use the skill to generate an initial test batch: describe your product, your audience, and the action you want people to take, and it produces a set of variations across different emotional angles (fear of missing out, social proof, curiosity, direct benefit) ready to A/B test.

Setup: 5 minutes. Best for: Facebook/Instagram ads, Google ads, LinkedIn campaigns, creative refresh.

6. Competitive Analysis: Know Your Market Before Your Competitors Do

Most small businesses have a vague sense of who their competitors are and a vaguer sense of how they actually compare. When a customer asks "how do you differ from X?" the answer is improvised. When pricing decisions are made, they're based on memory of a website check from six months ago.

A competitive analysis skill structures the job from end to end. Give it your top competitors and it produces a side-by-side comparison across features, pricing tiers, positioning language, go-to-market approach, and target customer profile, plus gap analysis showing where you have differentiation opportunities they haven't exploited.

"Analyze my top 4 competitors in the local accounting software market. Compare their pricing, feature sets, positioning, and messaging. Where do they all have gaps? What do they all claim that nobody actually differentiates on?"

The output is a living document. Update it quarterly when competitors change pricing, launch features, or shift messaging. Your competitive positioning stops being based on intuition and starts being based on evidence. That changes how you sell, how you price, and how you talk about your product.

Setup: 10 minutes. Best for: pricing decisions, sales talking points, product roadmap, pitch deck positioning.

Which One to Set Up First

If you've never used a Claude Skill before, start with the one that solves a pain point you felt this week. Not last year. This week. The skill that addresses something actively costing you time or money is the one you'll actually use, which means you'll see the return on the 5 to 10 minutes of setup immediately.

A few common starting points by situation:

You sign contracts regularly: start with Contract Review. The first contract you analyze will show you exactly how it works.

You're spending money on ads: start with Ad Copy. More creative, cheaper to test, faster to find what works.

You have a pitch or loan application coming up: start with Business Plan. The deadline is motivating and the output is tangible.

You've never reviewed your full spending: start with Budget Analyzer. The first look is always revelatory.

Once you've used one, the pattern clicks: folder, CLAUDE.md, open Claude, describe the task. Every other skill works the same way. The hardest part is the first one, and that takes about ten minutes.

Getting Started

I maintain a full library of free, downloadable Claude Skills at claudecodehq.com. Every skill in this article (and dozens more) is available as a one-click download. No coding, no configuration, just the CLAUDE.md file dropped into a folder and you're working.

Originally published on claudecodehq.com

I Tried Claude Skills for the First Time. Five Minutes Later, I Understood the Hype.

Daniel Marin — Mon, 04 May 2026 18:30:11 +0000

A beginner's guide to Claude Skills: what they are, how they work, and three examples you can try right now without writing a single line of code.

If you've heard the term "Claude Skills" and wondered what it actually means, you're not alone. It's one of those phrases that gets thrown around in AI communities without much explanation. Is it a feature you have to unlock? A paid add-on? Something only developers can use?

None of the above. Claude Skills are simple, free, and genuinely useful. And you can use your first one in about five minutes.

What Are Claude Skills?

A Claude Skill is a set of instructions that tells Claude how to behave for a specific task. Instead of explaining your requirements from scratch every time you use Claude, you drop a pre-written instruction file into your project folder. Claude reads it automatically and immediately knows exactly what role to play, what format to use, and how to handle your specific situation.

The instruction file is called a CLAUDE.md file. That's it. The "skill" is really just a well-written CLAUDE.md that someone has already crafted for a particular job.

A concrete analogy. Imagine hiring a contractor. Without instructions, you'd spend the first hour explaining your preferences, your style, your constraints. With a good briefing document, they hit the ground running. A Claude Skill is the briefing document: written once, reused every session.

The key insight is that context is power. A general-purpose AI and a Claude with a well-crafted skill file are night and day. The general AI has to guess your preferences, invent a format, and hedge its outputs. Claude with a skill already knows your preferences, your format, and your goal. So every response is immediately usable.

How Do Claude Skills Work?

No coding required. Here's the complete picture:

You create a folder on your computer for a specific project or task (for example, ~/Documents/MyBlog).
You download a skill (a CLAUDE.md file) and put it in that folder.
You open Claude Code from inside that folder. Claude automatically reads the CLAUDE.md file and loads the skill.
You start working. Claude already knows the context and behaves according to the skill's instructions from your very first message.

You don't configure anything. You don't write any code. The folder is the "on switch."

Setup in three commands:

mkdir ~/Documents/MyProject
# Move your downloaded CLAUDE.md into that folder
cd ~/Documents/MyProject
claude  # Claude reads CLAUDE.md automatically

What Makes a Good Skill?

A well-crafted CLAUDE.md skill typically defines five things:

1. Role and persona. Who Claude is in this context: "You are a personal budget analyst" or "You are a blog post editor with an opinionated voice."

2. Task scope. Exactly what Claude should do and, just as importantly, what it should not do. Scope prevents Claude from going off-piste.

3. Output format. The structure of every response, whether that's a numbered risk list, a markdown blog draft, or a spending breakdown by category.

4. Edge-case handling. What to do when something is ambiguous, incomplete, or outside the skill's scope. Good skills answer "what if" before it happens.

5. Examples. Sample inputs and outputs that calibrate Claude's understanding. The more concrete the example, the more accurate the behavior.

The best skills are written by people who use them daily (developers, researchers, marketers, freelancers), which means the edge cases are handled, the format is refined, and the output is immediately usable. You get the benefit of their iteration without doing the work.

Three Beginner-Friendly Skills to Try First

The best way to understand what Claude Skills feel like is to use one. Here are three options that each solve a common, concrete problem. No technical background required.

1. Tame Your Downloads Folder Once and for All

Most people have a Downloads folder they're a little embarrassed about. Screenshots mixed with invoices, installers that were supposed to be temporary, PDFs with names like "final_v3_REALLYFINAL.pdf." The folder has become a second desktop, which means it's functionally useless.

A file organizer skill handles the whole job in one go. Point Claude at your Downloads folder and it sorts every file by type (images, documents, videos, installers, archives), flags duplicates, archives old files by year, and produces a summary of what went where. 2,000 files organized in the time it would take you to make a decision about the first ten.

"Organize my Downloads folder. Group by file type, archive anything older than a year, and flag duplicates before deleting them."

This is a great first skill because the result is immediately visible and satisfying. You'll understand exactly what Claude did, and you'll have a mental model for how skills work in general.

2. Write a Complete Blog Post With Distribution Baked In

Writing a blog post is only half the work. After the draft comes the social thread, the email teaser, the title variants for A/B testing, the CTA you still haven't decided on. Most writers get the draft done and then stall on the distribution layer, which means the post sits unpublished while context evaporates.

A blog writing skill collapses all of that into one session. Give it a topic and it produces: five title options, an SEO-structured outline, a polished 1,800-word draft, an X thread version, an email teaser, and three CTA variants. Everything you need to publish and promote, in a single prompt.

"Write a blog post about why freelancers should track their time even on flat-rate projects. Conversational tone. Target audience: independent consultants."

This skill is a good demonstration of the format-definition power of skills. The output structure is defined in the CLAUDE.md, so every post comes back in the same shape. No formatting back-and-forth. No "can you also give me a social version?" It's already there.

3. Find Out Where Your Money Is Actually Going

Most people have a vague sense of their spending. They know roughly what rent is. They're less sure about groceries. They have no idea about subscriptions: those $12.99 and $9.99 charges that add up to $200+/month in things they half-forgot they signed up for.

A budget analyzer skill takes your bank statement or transaction CSV and produces a real picture: every transaction categorized, monthly spending by category charted, subscription creep surfaced (with the exact services and costs), and a realistic suggested budget based on your actual habits rather than an imagined ideal.

"Analyze my last three months of transactions. Categorize everything, show me what I spent the most on, and list every subscription charge."

This skill shows Claude Skills at their most personal. It's analyzing your data about your life, locally on your machine, without it going anywhere. That's worth understanding before you try it: Claude Code runs locally, so your financial data stays on your computer.

Common Questions From Beginners

"Do I need to know how to code?"

No. The three skills above require zero coding. You create a folder, drop in a file, and type your request in plain English. Some advanced skills produce code as their output (like data analysis or pipeline playbooks), but you don't write any to use them.

"Is Claude Code the same as Claude.ai?"

Claude.ai is the web chat interface. Claude Code is a separate tool that runs in your terminal. It's what makes Skills possible, because it can read files from your computer (including CLAUDE.md), run commands, and work with local data. You need to install Claude Code to use these playbooks. The installation takes about two minutes.

"Can I use a skill more than once?"

Yes, that's the point. The CLAUDE.md file stays in the folder permanently. Every time you open Claude Code in that folder, the skill is active. You can run the budget analyzer on a new bank statement export each month. You can write a new blog post with the writer skill anytime. The skill is always there.

"Can I have multiple skills at once?"

Each folder has one CLAUDE.md, so each project uses one skill. But you can have as many folders as you like: a Downloads folder with the organizer skill, a blog folder with the writer skill, a finances folder with the budget skill. Different contexts, different skills.

"Can I edit the CLAUDE.md to customize it?"

Absolutely, and this is where skills get powerful. The CLAUDE.md is just a text file. Open it in any text editor and adjust it for your preferences. Add your specific format requirements, your tone preferences, your company's terminology. The more you customize it, the more it feels like a tool that was built just for you.

Getting Started

The first skill takes five minutes. The second one takes two, because by then you already know the pattern. Within an hour you'll have a sense of what the library can do for you, and a short list of skills you want to set up permanently.

I maintain a full library of free, downloadable Claude Skills at claudecodehq.com, covering writing, research, finance, coding, legal review, marketing, data analysis, and more. All built and tested by people who use them on real work. The beginner-friendly ones are labeled clearly, so you can start simple and work your way up.

Once you've used one skill and understood the pattern (folder, CLAUDE.md, open Claude, ask a question), every other skill works the same way. The only difference is the job it does.

Originally published on claudecodehq.com

I Stopped Wrestling With Spreadsheets. Here's How I Go From Raw CSV to Insights in Minutes.

Daniel Marin — Thu, 30 Apr 2026 16:12:57 +0000

How to profile a new dataset, ask plain-English questions of your data, build presentation-ready dashboards, and run full analysis pipelines without knowing formulas or Python.

A CSV file is an answer waiting to happen. The question is whether getting that answer takes thirty seconds or three hours.

For most teams, it's three hours: open the file, realize it has 60 columns and no documentation, spend 45 minutes just understanding what you're looking at, try to remember the VLOOKUP syntax, build a pivot table that answers half of your question, start over in Python, give up and ask the data team.

AI data analysis compresses that loop dramatically. Not by doing magic, but by handling the exact steps that eat the time: profiling a new dataset, answering ad-hoc questions without formula gymnastics, generating visualization code, and running reproducible pipelines from cleaning through to final output.

This guide walks through four workflows that take you from raw data to usable insight in minutes.

The Before/After of Data Work

The comparison is starker than it sounds for people who haven't experienced it.

Scenario 1: Someone hands you a new dataset.

Before: 45 minutes. Open in Excel, scroll through columns, Google what unit each field is probably in, realize there are 12,000 nulls in a key column, manually check distributions on 6 columns, still not sure if you understand the data well enough to analyze it.

After: 3 minutes. AI profiles all 60 columns (types, distributions, null map, outliers, correlations) and gives recommended next analyses. You start the actual work understanding what you have.

Scenario 2: Manager asks a question about last quarter's data.

Before: 30 minutes. Find the right CSV export, build a pivot table, realize the date column format is wrong, fix it, rebuild, export to chart, realize the chart is the wrong scale, fix again. Send the screenshot.

After: 90 seconds. Ask in plain English. Get the answer with supporting numbers and a chart. Ask two follow-up questions. Done.

Workflow 1: Profile Any New Dataset in Minutes

Every data project starts with the same problem: you have a file you don't fully understand. Before you can analyze anything, you need to know what you're working with. Column types, value distributions, missing data patterns, outlier presence, relationships between fields. This "first look" step is invisible in most project estimates but routinely consumes an hour or more.

Point AI at any CSV (500 rows or 500K rows) and it produces:

Column classification (numeric, categorical, date, free text, ID) with inferred semantics
Distribution summaries for numeric columns (mean, median, std, percentiles)
Cardinality and top-value analysis for categorical columns
Missing value map: which columns have nulls, how many, whether the pattern is systematic
Outlier detection: rows with values that are statistically anomalous
Cross-field relationship discovery: which column pairs show strong correlations
Data quality flags: duplicates, inconsistent formats, suspicious value ranges
Recommended next analyses based on what the data seems to be measuring

"Profile this 500K-row customer dataset. I need to understand the column structure, data quality issues, and what analyses are worth running before I start."

The output is a data brief. Not just a dump of statistics, but an interpretation of what those statistics mean for your analysis. If the "signup_date" column has a suspicious cluster of nulls for records from one region, that's flagged as a data quality issue, not just a missing-value count. If "customer_age" and "account_value" are highly correlated, you know that going into the analysis.

Workflow 2: Ask Plain-English Questions of Your Data

The vast majority of data questions in a business are not complex. "Which product had the highest return rate last quarter?" "What's our average deal size by industry?" "Show me which sales reps are above quota." These questions have straightforward answers in the data. The problem is that getting the answers requires either knowing Excel formulas, being comfortable with SQL or Python, or bothering the data team for something that should take thirty seconds.

AI removes that prerequisite entirely. You ask your question in plain English; it analyzes the relevant columns, runs the right calculation, and gives you the answer with supporting numbers and a chart.

"Which region had the highest growth rate last quarter compared to the quarter before? Show me the breakdown by product category within that region."

The interaction is conversational. You can ask follow-up questions without re-explaining the dataset, and the system surfaces insights you didn't think to ask about. "Here's the answer. Also worth noting that the third-best region outperformed on margin even though it underperformed on volume." That's the kind of observation a good analyst makes. With AI, it happens automatically.

Who benefits most. This workflow has the highest leverage for non-technical users who are data-adjacent: operations managers, account executives, marketing managers, small business owners. People who have data and have questions about it, but whose job isn't data analysis. They shouldn't need to learn pivot tables to answer a business question. And now they don't.

Workflow 3: Build Presentation-Ready Dashboards

Analysis for your own decision-making is one thing. Analysis for a stakeholder presentation is harder. The same numbers need to be in charts that are polished enough for a board deck, exportable as PNGs, and ideally interactive enough that someone can explore the data themselves without asking you for a new version every time a question changes.

This is where most teams reach for Tableau ($70/month, steep learning curve) or accept that Excel charts look amateurish in presentations. There's a better middle ground.

AI generates professional visualizations directly from your CSV: interactive HTML dashboards built with Plotly (shareable as a standalone file), publication-quality static charts (exportable as PNG or SVG for slides), and statistical summary reports. No Tableau license, no D3.js tutorial.

"Create a sales dashboard from our Q1 data CSV. Include: revenue by region (bar chart), monthly trend with forecast (line), rep performance vs. quota (scatter), and product mix breakdown (treemap). Export as a shareable HTML file and PNG versions for the slide deck."

The output is a self-contained interactive dashboard (hover tooltips, filters, and drill-downs included) plus static PNG exports for each chart type ready to drop into slides. One prompt, one session, presentation ready.

Chart types available: histograms and distribution plots, line and area charts with trend lines and forecasting, bar and grouped bar charts, scatter plots with regression lines, heatmaps for correlation matrices and time-series patterns, treemaps and sunbursts for hierarchical data, and box plots for distribution comparison across groups.

Workflow 4: End-to-End Analysis Pipelines

The three workflows above handle ad-hoc analysis well. But research-grade and publication-grade analysis requires something more structured: a reproducible pipeline where every step (cleaning, transformation, modeling, visualization) is documented, version-controlled, and can be re-run when the data updates.

This is the gap between "I answered the question" and "I built something that answers the question reliably." Graduate students preparing dissertation analyses, researchers producing publication figures, data scientists building team-standard workflows: they all need the pipeline version, not just the one-off version.

"Build an end-to-end analysis pipeline for this survey dataset. Steps: data cleaning and validation, exploratory analysis with distributions and correlation matrix, regression models (OLS and logistic), publication-quality visualizations for each finding, and a results summary. Output as reproducible Python code."

The pipeline outputs actual code, not just results. Each step is a function with clear inputs and outputs, so when your dataset updates next month, you re-run the pipeline rather than redoing the analysis from scratch. The visualizations match publication standards: proper axis labels, consistent color schemes, vectorized outputs, captioned figures.

Picking the Right Workflow for Your Situation

The four workflows address four distinct situations. Knowing which one fits your context avoids spending 20 minutes with the wrong tool:

New dataset, no idea what's in it: start with dataset profiling. Always the first step when you're handed data with limited documentation. Understand before you analyze.

Specific business question from a dataset you already know: plain-English analysis. Best for non-technical users or for fast answers that don't need to be reproducible.

Need charts for a presentation or dashboard: data visualization. When the output needs to be presentable: interactive HTML dashboards, PNG exports for slides, or statistical reports.

Research-grade or reproducible analysis: full pipeline. When the work needs to be re-run, documented, or publication-ready. For researchers, data scientists, and teams building standard workflows.

Common Questions

"How large a dataset can these handle?"

For plain-English analysis and dataset profiling, datasets up to a few hundred thousand rows work well in a single session. For larger datasets, the pipeline workflow generates Python or R code that runs locally against the full dataset, so there's effectively no size ceiling as long as your machine can load it.

"Is my data safe?"

Claude Code runs locally. Your CSV files stay on your machine during the analysis session. This matters for datasets with PII, financial data, or other sensitive content. You're not uploading to a third-party web service that might store or log it.

"Do I need to know Python or R to use these?"

For plain-English analysis, visualization, and dataset profiling: no. These work entirely in natural language. You ask questions and get answers. For the full pipeline workflow, AI writes the code for you. Basic familiarity with Python or R helps you review and modify the output, but you don't need to write it.

"Can AI make up numbers in data analysis?"

No. Unlike tasks where AI generates information from its training data, these workflows operate on data you provide. The calculations are deterministic: the average is computed from your numbers, not estimated. Where uncertainty exists (in forecasting or modeling, for example), it's surfaced explicitly rather than presented as a point estimate.

Getting Started

If you're new to AI-assisted data analysis, start with the plain-English analyst workflow on a dataset you already know well. Ask it a question whose answer you already know. Verify the output, then ask something harder. Seeing it work on familiar territory makes it easy to trust on unfamiliar ground.

I publish free playbooks for all four workflows at claudecodehq.com: dataset profiling, plain-English CSV analysis, presentation-ready visualization, and end-to-end reproducible pipelines. Each one is a ready-to-use template you can drop into a project and start running immediately.

The thirty-second insight has always been possible for data teams that know the tools. What changes with AI is that it's now possible for anyone who has the data and knows the question. The bottleneck shifts from "can you write the query?" to "do you know what to ask?", which is where it should have been all along.

Originally published on claudecodehq.com

Most People Use AI for Research Wrong. Here's the Framework That Actually Produces Insight.

Daniel Marin — Mon, 27 Apr 2026 19:10:46 +0000

How to go from "a better Google" to genuine analysis: question decomposition, multi-source synthesis, contradiction detection, and reports worth making decisions from.

Most people use AI for research the wrong way. They type a question, get a summary, and treat the summary as research. That's not research. That's a better Google.

Real research involves decomposing a question, tracking what each source actually says, identifying where sources agree and where they contradict each other, finding the gaps no existing source addresses, and synthesizing everything into a structured argument with evidence behind each claim.

Deep research with AI is different from shallow research with AI in the same way that a consultant's report is different from a Wikipedia summary. The output reflects not just what's known, but the structure of what's known, what's contested, and what nobody has figured out yet.

This guide walks through a four-layer framework so that the AI research you produce is actually usable for high-stakes decisions.

The Problem With Surface-Level AI Research

AI is extraordinarily good at one specific thing: retrieving and recombining existing knowledge. Asked "what are the challenges of entering the European market?" it can produce a competent list in seconds. The problem is that a competent list of challenges is not research. It's the starting point for research.

Genuine research asks harder questions. Which challenges matter most for your specific industry, business model, and expansion timeline? Where do studies and expert opinions actually disagree, and why? What does the evidence say when you triangulate across sources rather than reading them one at a time? What does nobody know yet, and does that gap affect your decision?

Shallow: "What are the pros and cons of launching in Europe?" produces a bulleted list of generic considerations you could have found in the first three Google results. Useful as orientation, not as a basis for a decision.

Deep: Question decomposed into eight sub-questions. Thirty sources read, synthesized, and cross-referenced. Four consensus findings, two direct contradictions between market studies, one gap (no good data on SaaS-specific regulatory timelines). Structured report with citations, confidence levels, and a recommendation section that reflects the uncertainty honestly.

The framework below closes that gap. It doesn't make AI do magic. It makes AI do the systematic work that turns a question into genuine analysis.

The Four-Layer Deep Research Framework

Every serious research project has the same underlying shape, whether it's a consulting deliverable, an academic literature review, or a competitive analysis. The four layers are: decompose, coordinate, synthesize, and structure. Most AI research workflows skip two or three of these.

Layer 1: Decompose. Break the research question into answerable sub-questions. Map dependencies. Prioritize which sub-questions have the most decision weight.

Layer 2: Coordinate. Track which sources address which sub-questions. Prioritize source types. Know what you've covered and what you haven't.

Layer 3: Synthesize. Cross-reference sources to find consensus, contradictions, and gaps. Surface patterns invisible in any single source.

Layer 4: Structure. Organize findings thematically, not source-by-source. Build a narrative where each claim has supporting evidence and a confidence level.

Layer 1: Question Decomposition and Research Scoping

The most common failure in AI research projects happens before any research gets done: the question is too broad to answer well, but nobody realizes it until three hours later. "What's the impact of remote work on company culture?" is not a research question. It's a topic. A research question is specific enough that you know when you've answered it.

Feed AI a broad research question; it breaks it into specific, answerable sub-questions, maps which ones are prerequisites for others, and identifies which sub-questions carry the most decision weight for your actual use case.

"Research question: Should we build our own data infrastructure or use a managed cloud provider? Decompose this into answerable sub-questions. Identify which ones I need to answer first, which depend on others, and which will have the most impact on the final recommendation."

What comes back is a research map. Not a list of topics, but a structured graph of sub-questions with dependencies and priority weights. This structure becomes the skeleton of your research project. Every source you read, every analysis you run, slots into one or more nodes on that map. You always know what you're trying to answer and whether you've answered it.

What good decomposition looks like. A question like "impact of remote work on company culture" decomposes into something like:

How is "company culture" operationalized in the existing literature?
Which culture dimensions are most affected by remote work (collaboration, trust, onboarding, retention)?
Does effect size differ by company size, industry, or pre-existing culture type?
What interventions have companies tried, and what is the evidence of effectiveness?
What methodological limitations affect the studies in this area?
What are the gaps: questions no existing study has adequately addressed?

Each of these is answerable. You can find a source that addresses it, or note that no source does. That's what makes decomposition the foundation of deep research.

Layer 2: Coordinated Multi-Source Research

Once the question is decomposed, the coordination challenge emerges: you're now reading 20, 30, or 50 sources and trying to remember what each one said about which sub-question. Without a tracking system, you're guaranteed to miss coverage, double-read, and lose the thread of which claims have strong support versus thin support.

Run each sub-question as a structured research task, pulling from multiple perspectives (empirical studies, practitioner accounts, contrarian views, historical analogues), tagging each finding by sub-question, and flagging when coverage is thin or one-sided.

"Research sub-question: 'What interventions have companies tried to maintain culture in remote settings, and what is the evidence of effectiveness?' Cover at least four perspectives: empirical studies, practitioner case studies, critical views, and historical analogues. Flag where evidence is weak."

Running research per sub-question (rather than against the whole question at once) is the key design choice. It forces coverage discipline. You get a structured finding set per node in your research map, rather than a single sprawling response that covers some nodes well and others superficially.

Layer 3: Cross-Source Synthesis and Contradiction Detection

This is the layer that separates genuine research from a well-organized reading list. Once you have findings from 20 to 30 sources, the synthesis question is: what do they collectively say? Not what does each one say, but what emerges when you read them as a body of evidence rather than as individual documents?

AI runs four analytical passes:

Consensus detection. Which claims are supported by multiple independent sources? These are your high-confidence findings. Important: multiple sources saying the same thing doesn't mean they independently verified it. The system flags citation chains where sources are all citing one original study.

Contradiction mapping. Where do sources directly disagree? Contradictions are often the most valuable finding. They signal either methodological differences, context-dependence, or genuine scientific uncertainty. All three are important to know before making a decision.

Gap identification. What questions are implied by your research map but not addressed by any source? Gaps are where the evidence doesn't support a confident conclusion, and where your recommendation needs to explicitly acknowledge uncertainty.

Cross-source narrative. A synthesized narrative of the state of knowledge. Not "Source A says X and Source B says Y," but "the evidence shows X, with the exception of contexts where Y, which may reflect Z."

"Synthesize these 25 sources on remote work culture impacts. Find consensus findings, direct contradictions between studies, and gaps no source addresses. Flag where multiple sources trace back to the same original study. Produce a cross-source narrative with confidence levels per claim."

Layer 4: Thematic Structuring

The final layer is turning your synthesized findings into a structured document that someone else can read and actually use. This is where most AI-assisted research falls apart: the findings are solid, but the output is a source-by-source summary instead of a thematically organized argument.

A source-by-source structure reads like: "Smith (2024) found X. Jones (2023) found Y. Chen (2022) found Z."

A thematically organized structure reads like: "The evidence shows X [Smith 2024, Jones 2023]. However, this finding may not hold in large organizations [Chen 2022, Kim 2021], where Y is more consistently observed."

Same evidence, completely different readability and utility.

For academic and policy research, this means grouping tagged papers by emergent theme rather than by source, producing a methodology comparison table, identifying under-researched areas, and drafting a narrative structured around insight rather than citation. For business research, the same principle applies in a different output format: findings structured by decision relevance, not by source, with explicit confidence levels on each recommendation.

A Complete Deep Research Workflow

Here's how the four layers work together on a real research project:

Define and decompose. Feed the broad question in. Get back a research map: sub-questions, dependencies, and priority weights. Confirm the scope before doing any research.
Research sub-questions systematically. Run multi-perspective research on each high-priority sub-question. Empirical, practitioner, critical, and historical coverage for each one.
Synthesize across sources. Once you have findings from 15+ sources, run cross-source synthesis. Get consensus findings, contradictions, gaps, and a narrative with confidence levels.
Structure the output. Organize findings thematically and produce the final deliverable.
Human judgment pass. Review the contradictions and gaps explicitly. Make the recommendation. AI can surface what's known and unknown. The judgment call based on that evidence is still yours.

For a research project that would traditionally take a week, this workflow typically takes a day, with higher source coverage and more explicit contradiction tracking than manual research usually achieves.

What AI Research Is Not

The limitations are real and worth being direct about:

AI does not have access to paywalled literature. For academic research, you still need institutional access to journals, or open-access repositories. AI synthesizes what you bring to it. It doesn't substitute for sourcing.

AI can confabulate citations. Any specific citation the AI produces should be verified against the original. The synthesis and pattern-finding are the valuable contribution. Treat specific citations as hypotheses to verify, not facts to rely on.

AI cannot assess source credibility automatically. It can note that a claim appears in a peer-reviewed study versus a blog post, but the domain judgment about whether that specific study is methodologically sound is still yours.

AI cannot make the recommendation. It can surface what the evidence says and where the uncertainty lies. The judgment about what to do given that evidence requires context the AI doesn't have.

These are not reasons to avoid AI-assisted research. They're reasons to use it at the right layer. AI handles decomposition, coordination, synthesis, and structuring. You handle sourcing, verification, credibility assessment, and recommendation.

Getting Started

The difference between surface-level AI research and deep research isn't the model. It's the process. Most people skip decomposition, do linear reading instead of cross-source synthesis, and output source summaries instead of thematic arguments. Fix the process, and the model you already have becomes dramatically more powerful.

If you're dealing with a big, messy research question and don't know where to start, begin with decomposition. It's always the highest-leverage first step. If you already have a pile of sources and need to make sense of them, go straight to synthesis. For academic literature reviews, the structuring layer is the piece that transforms a reading list into a real argument.

I publish free playbooks for all four layers of this framework at claudecodehq.com: research coordination and decomposition, multi-perspective deep research, cross-source synthesis with contradiction detection, and thematic literature review building. Each one is a ready-to-use template you can drop into a project and start running today.

Every question worth researching is worth researching thoroughly. And thoroughness is now a one-day workflow, not a one-week one.

Originally published on claudecodehq.com

My Cold Email Reply Rate Went From 2% to 12%. Here's the AI Framework Behind It.

Daniel Marin — Sat, 25 Apr 2026 17:34:25 +0000

Proven templates, personalization that isn't faked, multi-touch sequences with branching logic, and the automation workflow that ties it all together.

The average cold email reply rate in 2026 is somewhere around 1 to 3%. That number hasn't moved in a decade, but the reasons it hasn't moved are completely different from what they used to be. A decade ago, cold email underperformed because nobody had time to personalize. Today, it underperforms because AI tools made template-spam trivial to send, inboxes learned to filter it, and prospects can smell generic outreach in three seconds. The bar to get a reply has risen permanently.

The good news: AI cold email still works. But only when you use AI to raise quality, not volume.

This guide walks through the template patterns that get replies in 2026, the personalization frameworks that actually move reply rates from 2% to 10%+, and the workflows that automate the parts that should be automated while keeping the parts that shouldn't.

Why Most Cold Email Still Fails

The usual failure isn't one obvious mistake. It's a stack of small ones. Each alone would only hurt performance a little; together, they kill the email.

Fake personalization. "Hi {FirstName}, I noticed your company..." Prospects recognize this instantly as a merge-tag template with no real research behind it.

Feature-dumping. Pitching your product's features instead of the specific outcome the prospect cares about.

Vague asks. "Do you have 15 minutes to chat?" with no reason to say yes.

Length. 300-word pitches in cold email get skipped. Anything over about 90 words loses the reader before the ask.

No sequence. One email, no follow-up. 80% of replies come from email 2 through 5.

Fixing any one of these moves reply rates a little. Fixing all five moves them dramatically.

Before: SDR sends 100 emails a day. Each one has {FirstName} and {Company} filled in. Reply rate: 2%. Most of those are "unsubscribe." Reps burn out, prospects burn out, and the top of the funnel slowly stops working.

After: AI researches each prospect before the email is written. The opening references a specific trigger: a recent hire, a product launch, a LinkedIn post, a funding round. The ask is concrete. The sequence adapts to behavior. Reply rate: 8 to 12%. Same rep effort, 4 to 6x the meetings.

The Template Structure That Actually Works

Almost every high-performing cold email in 2026 follows the same four-beat structure:

1. Specific trigger (1 sentence). Something that proves you did actual research on this prospect. A quote from their podcast appearance, a specific claim from their job posting, a metric they mentioned in a LinkedIn post. Not "I saw your company is growing."

2. Inferred problem (1 sentence). Based on that trigger, what's the specific pain the prospect is probably experiencing right now? Not "companies like yours struggle with X." This prospect, this situation.

3. One concrete outcome (1 sentence). What changes if they work with you, stated as a specific outcome, not a feature list. "Cut your onboarding time from 14 days to 3" beats "our platform has onboarding workflows."

4. Soft ask (1 sentence). "Worth a 15-min chat?" fails in 2026. Better: "I put together a 2-minute Loom showing how we'd do this for you. Want me to send?" Lower commitment, higher specificity.

Four sentences. Maybe 75 words. Every beat earns its place. This is the structure that actually survives the prospect's 3-second skim.

A Template You Can Copy

This isn't a template in the merge-tag sense. The personalization has to be real. But the shape of a high-converting cold email looks like this:

Subject: {specific detail from their world}

Hey Sarah,

Caught your post last week about hitting 40% YoY growth but your CS team headcount only growing 15%. Sounds like a familiar scaling pain.

When that ratio widens, the usual side effect is onboarding debt: NPS quietly drops 2 to 3 months later, and nobody can figure out why.

We help CS teams in the same spot cut first-response time by 60% without adding headcount. Loom's CS team went from 14-day onboarding to 3.

Worth seeing a 2-min Loom of how we'd do this for you specifically? I'll put it together if you're open.

Alex

Notice what's not there: no "hope this finds you well," no company overview, no bullet-point feature list, no calendar link. Every sentence earns its place. The whole email is under 90 words. It reads like a peer talking to a peer, because the research behind it actually justifies that tone.

Phase 1: Personalize at Scale (Without Faking It)

The bottleneck in cold email isn't writing the email. It's the 10 minutes of research that makes the first sentence not suck. Manually researching 100 prospects is a day's work. Most SDRs skip it and the emails go out worse.

AI automates the research layer: for each prospect, it pulls public signals (recent LinkedIn posts, company news, podcast appearances, job postings, funding announcements) and generates a personalized opening paragraph referencing the most relevant signal. Your voice, your template structure, 100% real research per email.

"Personalize cold emails for these 100 CS leaders. Use our template structure. For each, pull their most recent public signal (LinkedIn post, podcast, company news) and write a specific opening that references it. Keep each email under 90 words."

The output is 100 emails with 100 genuinely different first paragraphs. Not 100 emails with the same first paragraph and a merge-tag swap. Because the research is real, the rest of the email doesn't need to work as hard. The opening earns the read.

Phase 2: Multi-Channel, Multi-Touch Outreach

A single email almost never closes a meeting. The conversion math of cold outreach is stacked heavily on touches 2 through 5, not touch 1. If you stop at one email, you're capturing about 20% of the replies that were available to you.

For each prospect, AI produces a full sequence: the initial email, a follow-up with a different angle, a LinkedIn connection message that complements the email, and a phone call script for reps who cold-call. Same research, coordinated across channels.

"Draft a 3-touch sequence for these 10 enterprise prospects. Email 1 references their most recent trigger event. Email 2 (day 4) adds a different angle with a case study from a similar company. LinkedIn message (day 2) mirrors email tone without repeating it. Include a phone script for reps who follow up by phone."

The key design principle: every touch has a different angle, not a different version of the same angle. Touch 1 references a trigger event. Touch 2 shows a case study. Touch 3 offers a specific resource. Each touch gives the prospect a fresh reason to reply, rather than just restating the original pitch with "just circling back" on top.

Phase 3: Sequence Design With Branching Logic

Outbound sequences are where most teams plateau. They set up a linear 5-email drip, everyone on the list gets the same messages on the same schedule, and behavior (opens, clicks, replies) doesn't influence the sequence at all.

Prospects who opened email 1 and didn't reply are in a completely different situation from prospects who didn't open email 1 at all. These call for completely different next touches.

AI designs sequences with real branching logic:

Opened but didn't reply: Touch 2 takes a different angle, not "just bumping this up."
Didn't open: Touch 2 uses a different subject line approach entirely. No point sending the same pitch at the same reader.
Clicked link but didn't reply: Touch 2 follows up on the content, not the pitch.
Replied negatively: Exit the sequence. Never "persistence-pitch" someone who said no.

"Design a 6-email outbound sequence for enterprise CS leaders. Include branching on open/click/reply behavior. Write copy for each branch. Include send-time recommendations and a visual flow diagram I can hand to our RevOps team."

The output is a full sequence with copy for each branch, optimal timing, exit conditions, and a visual flow diagram. Plug it into your sending tool (Outreach, Apollo, Instantly, Smartlead) and your sequences start adapting to behavior instead of blasting on a timer.

Putting It Together: An End-to-End Outbound Workflow

Here's how these three phases work together for a typical outbound campaign:

Design the sequence structure. Get the full 5 to 7 touch sequence with branching logic before you've written a single email.
Personalize the opening touches. Fill in the personalized first paragraph for every prospect on your list based on real research.
Layer in multi-channel. LinkedIn messages and phone scripts get drafted alongside the email sequence, keyed to the same research.
Load into your sending tool. Export to Outreach, Apollo, or Smartlead. Set up the branches according to the flow diagram.
Review and launch. A 5-minute human pass per prospect catches anything that sounds off (usually nothing, but worth doing). Then launch the campaign.

What used to be 8 hours of research, writing, and sequence design for 100 prospects becomes 30 to 45 minutes of running the workflows and reviewing the output. The quality goes up, not down, because every email has real research behind it instead of a merge-tag substitute.

What Good AI Cold Email Is Not

It's worth being explicit about what this approach isn't, because there's a version of AI cold email that's actively making the whole channel worse:

Not high-volume spray-and-pray. If the answer to "how many emails should I send per day?" is "as many as my sending infrastructure allows," you're using AI to lower quality, not raise it.

Not AI-generated "personalization" that isn't real. If the AI is hallucinating details about the prospect, you're worse off than a merge-tag template. Prospects notice, remember, and tell their network.

Not fully autonomous. Keep a human in the loop. A 5-minute review pass per campaign prevents 95% of the failures that make AI cold email look terrible.

Not a replacement for ICP discipline. Emailing the wrong people with excellent personalization still gets 0% reply rate. AI doesn't fix a bad list.

Common Questions

"Does AI-written cold email trigger spam filters?"

Not directly. Spam filters look at sending patterns, authentication, and content signals, not provenance. What gets you filtered is sending high volumes of similar content to low-engagement inboxes. Highly personalized emails, even AI-assisted ones, land in primary inboxes because they behave like legitimate 1:1 outreach.

"How do I avoid the 'obviously AI-written' tone?"

Two things. First, give the AI sample emails in your voice: your rhythm, your sentence length, your actual words. It matches style to the samples. Second, do a 30-second human pass on each email to swap out any phrase that sounds templatey. The combination eliminates the tell almost entirely.

"Is this compliant with CAN-SPAM / GDPR?"

AI doesn't change your compliance obligations. You still need an unsubscribe mechanism, a legitimate interest basis (or consent in GDPR jurisdictions), and a real sender identity. You need to bolt on unsubscribe links, suppression lists, and sender verification as you would for any outbound program.

"What reply rate should I actually expect?"

For tightly-targeted ICP lists with genuinely personalized emails and a 5-touch sequence, well-run campaigns see 8 to 15% reply rates. For broader top-of-funnel work, 4 to 8% is realistic. If you're under 2%, it's usually list quality, not email quality.

Getting Started

Cold email isn't dying. Template-spam is dying, which is different. The teams winning in 2026 aren't the ones sending the most emails. They're the ones sending emails a prospect can tell were written for them. AI makes that level of personalization scalable for the first time.

I publish free playbooks for all three phases of this workflow (personalization at scale, multi-channel sequencing, and branching sequence design) at claudecodehq.com. Each one is a ready-to-use template you can drop into a project and start running against your prospect list today.

The prize goes to the teams that use AI to raise the ceiling, not lower the floor.

Originally published on claudecodehq.com

I Turned One Blog Post Into 10 Pieces of Content. Here's the Exact Framework.

Daniel Marin — Thu, 23 Apr 2026 18:37:34 +0000

How to stop publishing once and walking away, and start getting two weeks of distribution from every article you write.

You spent twelve hours researching and writing a 2,000-word blog post. It went live on Tuesday. By Friday, organic traffic has trickled down to nothing, and the article is quietly collapsing into your archive. Meanwhile, your competitors are somehow on every platform every day with seemingly endless content.

They don't have bigger teams. They just aren't publishing once and walking away.

This is the core unlock of AI content repurposing: one deeply researched blog post contains enough raw material to fuel two weeks of platform-native posts across X, LinkedIn, Instagram, YouTube, and your newsletter. You just need a system to extract it.

Why "Publish Once" Is the Worst Content Strategy

Most solo creators and small content teams fall into the same trap: they write one great piece of content, publish it on their primary channel, and move on.

The math is brutal. Average blog-post lifetime traffic peaks within 72 hours. Average X engagement window is 48 hours. LinkedIn posts get 90% of their views in the first week. If your workflow is "write, publish once, start over," you're running the expensive part of the process (research, drafting, editing) without amortizing it across enough distribution.

Content multiplication fixes that ratio. Instead of ten original pieces of content per month, you publish one deeply researched anchor piece and derive ten distribution artifacts from it. Same research effort, 10x the surface area.

Before: One blog post published Tuesday, promoted with a link-drop on X and LinkedIn. Dies by Thursday. You go quiet for a week while drafting the next original piece. Audience growth is a slow, random walk.

After: One blog post Tuesday. Wednesday: an X thread, a LinkedIn long-form post, three standalone X posts, two LinkedIn carousels, a YouTube Shorts script, an Instagram carousel, a newsletter teaser, and a reply-guy content pack. The original article feeds 10+ posts across two weeks.

The 10-Piece Repurposing Framework

Not every section of a blog post can be repurposed. The trick is recognizing what type of artifact each section naturally becomes. Most good long-form articles contain the same repeating building blocks: a contrarian claim, a list of insights, a framework, a case study, a before/after comparison, a data point, and a conclusion. Each maps cleanly to a specific social format.

Here's the framework:

1. X thread (8 to 12 posts). The article's main argument broken into a narrative-driven thread. Strong hook post, one claim per tweet, ending with a link back to the full article.

2. LinkedIn long-form post. Same argument, different tone: professional, takeaway-oriented, with clear line breaks and a "what this means for you" close.

3 to 5. Three standalone X posts. Individual insights that stand on their own without needing the full thread. Pulled from the sharpest single-sentence claims in the article.

6. LinkedIn carousel (framework). If the article contains a named framework or numbered list, it becomes a 6 to 10 slide carousel with one concept per slide.

7. Instagram carousel (before/after). The before/after comparison from the article rendered as a visual carousel. Works exceptionally well for tutorial and transformation content.

8. YouTube Shorts / TikTok script. The most counterintuitive claim in the article, scripted as a 45 to 60 second hook-driven video with captions.

9. Newsletter teaser. A stand-alone newsletter section that previews the insight and links to the full article. Often the most reliable traffic driver for existing audiences.

10. Reply-guy pack (5 to 10 replies). Pre-drafted replies you can drop into relevant threads on X or LinkedIn. Each one adds a specific insight from your article without being a self-promotional link-drop.

Ten pieces from one article, each actually native to its platform. Not a copy-paste of the same text with different character limits. This is what AI repurposing does that manual repurposing doesn't: it changes the voice for each platform, not just the length.

Step 1: Multi-Platform Repurposing From a Single Anchor

The fastest way to get from blog post to ten pieces is a single orchestrator that knows the quirks of every platform. X wants narrative hooks and punchy rhythm. LinkedIn wants takeaway-oriented professional framing. Instagram wants visual storytelling. YouTube Shorts wants the counterintuitive claim in the first three seconds. Writing for each correctly is a different craft, and the reason manual cross-posting feels so miserable.

Feed AI one article; it produces complete drafts for every major platform plus a two-week posting schedule.

"Take my new 2,000-word article on pricing psychology and turn it into content for all my platforms: X thread, LinkedIn article, Instagram carousel, YouTube Shorts script, and a newsletter teaser. Give me a 2-week posting schedule."

What you get back: platform-native drafts (not platform-adapted drafts), each with a distinct voice and structure, plus a schedule that respects each platform's optimal posting cadence. X gets daily frequency, LinkedIn gets 3 to 4 per week, Instagram gets 2 to 3 per week, YouTube gets weekly. Same raw material; completely different outputs.

Step 2: Recurring Repurposing From Newsletters and Podcasts

If you're already producing long-form content on a cadence (a weekly newsletter, a podcast episode, a YouTube video), the repurposing job isn't one-shot. It's recurring. Every Monday, last week's newsletter should auto-generate next week's social queue. This is where automation stops being "nice-to-have" and becomes structural.

"Every Monday at 9am, check my newsletter folder for last week's edition, and generate 6 X posts and 6 LinkedIn posts from it. Save drafts to my content queue folder ready for me to review and schedule."

The advantage of the recurring pattern is that it removes the friction that kills most content-repurposing habits: the 30 minutes of context-switching every time you sit down to do it. When the drafts are already sitting in a folder Monday morning, you just review, tweak, and queue. The hard creative work is already done.

Step 3: Filling the Gaps With a Full Content Engine

Ten pieces from one article still leaves gaps. Real content calendars aren't just "the same idea ten ways." They mix repurposed anchor content with original shorter posts: polls, questions, hot takes, behind-the-scenes. Without these, your feed starts to feel like an echo chamber of your own blog.

"Generate 30 days of LinkedIn and X posts for our SaaS product. Content pillars: thought leadership (40%), product tips (30%), customer stories (20%), industry insights (10%). Mix text posts, threads, poll questions, and carousel outlines."

The three workflows together form a complete system: multi-platform repurposing for one-off blog-to-everything projects, recurring automation for weekly newsletter and podcast outputs, and a content engine for the "variety filler" that keeps your feed from feeling one-note.

A Realistic Week-by-Week Workflow

Here's how this actually operates for a small team or solo creator producing one long-form piece per week:

Monday. Publish the anchor piece (blog post, newsletter, or podcast episode).

Tuesday morning. Run the repurposing workflow. Review the 10 derived pieces. Tweak voice where needed. Usually minor adjustments, not rewrites.

Tuesday afternoon. Queue the posts in your scheduler (Buffer, Hypefury, Typefully). The built-in schedule tells you exactly when each one should go out.

Wednesday to Sunday. The queue publishes automatically. You respond to engagement but don't need to create.

In parallel. The content engine generates "variety filler" posts for the week (polls, hot takes, behind-the-scenes) to mix into the calendar alongside the repurposed anchor content.

The net result: one week of focused writing on the anchor piece produces two weeks of distribution across five platforms. Your time-per-post drops dramatically, but importantly, so does the creative fatigue of constantly having to invent the next idea.

What Good AI Repurposing Actually Looks Like

The failure mode of bad AI repurposing is obvious: the same sentence on six platforms, each slightly reformatted, all of them clearly written by the same tool. It looks lazy because it is lazy.

Good AI repurposing avoids this by changing three things platform-to-platform:

Voice. X leans casual and punchy. LinkedIn leans measured and professional. Instagram leans visual and warm. The same insight needs three different tones, not three different word counts.

Structure. Threads build narrative across posts. LinkedIn builds it in paragraph breaks. Shorts build it in a 3-second hook and payoff. The underlying idea is the same; the structural scaffolding is completely different.

Angle. Not every insight lands on every platform. A contrarian hot take thrives on X and underperforms on LinkedIn. A detailed framework works on LinkedIn and feels too long on X. Good repurposing picks the right subset for each platform rather than forcing everything everywhere.

Common Questions

"Will my audience notice I'm repurposing?"

Almost nobody follows you on all the platforms. Your X audience doesn't overlap with your LinkedIn audience, which doesn't overlap with your newsletter list. Repurposing isn't "posting the same thing everywhere." It's "letting each audience access the best ideas from your work." The few followers who do see it across platforms generally recognize it as thoughtful cross-posting, not spam, as long as the voice is genuinely adapted.

"Doesn't AI-written content sound generic?"

Only if you let it. The AI uses your original writing as source material, so the voice carries over. Its job is structural translation, not generation from scratch. Always do a human review pass (usually 5 to 10 minutes per platform) to catch anything that sounds off. The time investment is still 10x less than writing from scratch.

"What if my blog post isn't 'repurposable' content?"

Most long-form posts have at least 5 to 10 extractable insights. If yours doesn't, that's actually a sign the article itself needs more structure: concrete claims, frameworks, before/after examples. Writing with repurposing in mind tends to make the original post better, not worse.

"Can I fully automate this, zero human review?"

Technically yes, practically no. The 5-minute human review pass is what separates "genuinely good content at scale" from "AI slop flood." Automate the generation, the scheduling, and the platform adaptation, but keep a human in the loop for the final voice check. Your audience can tell the difference.

Getting Started

If you publish long-form content sporadically, start by running the repurposing workflow on your best-performing article from the last quarter and see what falls out. If you publish on a weekly cadence, set up recurring automation. If you need to fill a blank calendar from scratch, start with a full content engine.

I publish free playbooks for all three workflows at claudecodehq.com: multi-platform repurposing, recurring content automation, and full-month content generation. Each one is a ready-to-use template you can drop into a project and start running immediately.

The first time you watch one blog post fan out into ten queued posts across five platforms, the leverage becomes obvious. The tenth time, when you realize you haven't stared at a blank LinkedIn composer box in three months, it stops feeling like a trick and starts feeling like how content is supposed to work.

Originally published on claudecodehq.com

The AI SEO Playbook I Used to Build a Full Content Pipeline in Half a Day

Daniel Marin — Wed, 22 Apr 2026 19:01:50 +0000

From keyword research to rank tracking: how to run a real SEO program without a full SEO team.

SEO changed more between 2024 and 2026 than in the previous decade. Google's AI Overviews eat click-through rates. LLM-generated content flooded the web, then got penalized, then got rewarded when it was good. The tools that worked (Ahrefs, SEMrush, Surfer) still work, but the winning workflow is no longer "use one big SaaS tool." It's "stitch together small, purpose-built AI workflows that each do one part of the job well."

This guide lays out a complete AI SEO strategy, from keyword research through topic cluster planning, content optimization, authority building, and rank tracking. By the end, you'll have a repeatable pipeline that takes you from "I need to grow organic traffic" to "here's next quarter's editorial calendar with briefs, on-page optimizations, and a link-building plan."

Why Traditional SEO Workflows Are Breaking

The old SEO workflow looked like this: pay $200/month for a keyword tool, export a CSV, paste it into a spreadsheet, manually cluster keywords into topics, write briefs in Google Docs, hand them to writers, spot-check the on-page optimization, and track rankings in a separate tool. Every step was a handoff. Every handoff lost information. And nobody had time to close the loop between what was ranking and what the next article should be about.

The new workflow collapses those handoffs. AI handles the mechanical parts (keyword expansion, clustering, brief generation, on-page optimization, competitor analysis) while you focus on the judgment calls: which clusters to prioritize, which angle to take, whether the draft actually answers the query.

Before: Three days of keyword research, spreadsheet clustering, and manual competitor audits to produce a quarterly content plan. By the time the first article ships, the research is stale.

After: Half a day. Seed keywords expand into hundreds of related terms, cluster into topic groups, map against competitor gaps, and emerge as a 12-week calendar with briefs attached. The strategic review fits in an afternoon.

The Five Phases of an AI SEO Strategy

A complete SEO strategy has five phases. Traditional workflows treat each as a separate project with its own tool. The AI-native workflow treats them as one connected pipeline.

Research: keyword expansion, intent classification, competitor analysis
Planning: clustering into topics, prioritizing by opportunity, building a calendar
Optimization: on-page SEO, internal linking, technical fixes
Authority: link acquisition, domain authority growth, digital PR
Measurement: rank tracking, traffic attribution, iteration

Phase 1: AI Keyword Research and Gap Finding

Every SEO strategy starts with the same question: what are people actually searching for? Traditional keyword research tools give you volume and difficulty numbers, but they don't tell you what your audience is actually struggling with right now. The best keywords aren't always the ones with the highest volume. They're the ones your audience is typing into Reddit and X before they think to Google them.

AI gap analysis scans Reddit threads, X posts, and niche forums for recurring pain points in your vertical, ranks them by frequency and emotional intensity, and cross-checks them against your existing content. The output isn't a keyword list. It's a list of topics your audience is currently confused or frustrated about, ranked by how urgent the pain is.

"Find content gaps in the B2B SaaS onboarding niche. Surface the 25 most-discussed pain points across Reddit and X over the last 90 days, ranked by intensity, and flag which ones we haven't written about."

This is where AI keyword research diverges from the traditional approach: traditional tools tell you what people are searching for. AI gap analysis tells you what they're about to start searching for. When a pain point is trending on Reddit, the Google search volume for it usually catches up within 30 to 60 days. Getting there first is how you rank on page one before the competition shows up.

Pairing with traditional keyword tools: This doesn't replace Ahrefs or SEMrush. It complements them. Run the gap analysis first to identify high-pain topics, then pull keyword volume and difficulty data from your paid tool for the specific terms AI surfaces. You end up with a keyword list that has both demand-side intensity and supply-side competitiveness data.

Phase 2: Topic Cluster Planning and Editorial Calendars

A list of keywords is not a strategy. A strategy is a set of topic clusters: tightly related articles that reinforce each other's rankings through internal linking and topical authority. Google rewards depth. A site with 20 articles on project management will outrank a site with 3 project management articles and 17 articles on unrelated topics, even if the individual articles are equally good.

AI handles the translation from keyword list to editorial calendar:

Expands seed keywords into 200+ semantically related terms
Clusters them into topic groups by search-intent similarity
Classifies intent (informational, commercial, transactional)
Runs a content gap analysis against your top 5 competitors
Produces a 12-week calendar with briefs: target keywords, suggested word count, outline, and internal link targets

"Plan our Q3 content calendar targeting 'project management' keywords. Build 15 topic clusters from 200+ related terms, gap-analyze against Asana, Monday, and ClickUp's blogs, and produce 12 weeks of content briefs."

Each brief includes the target keyword, the intent, the cluster the article belongs to, the competitors currently ranking, what they're missing, and a structural outline. If you're running a small team, this is the artifact that replaces three days of strategy work per quarter.

Phase 3: AI Content Optimization (On-Page SEO)

You can publish a brilliant article and still rank on page three because the on-page SEO is inconsistent. Title tags that don't match intent. H2 structure that buries the answer. Internal linking that doesn't pass authority. Schema markup that's missing or malformed. These aren't content problems. They're execution problems, and they're perfectly suited to AI automation.

Point AI at a page, a draft, or a whole site, and it runs through a systematic optimization pipeline:

On-page elements. Title tag and meta description tuned to target keyword and intent. H1/H2 structure checked for topical completeness. Image alt text, URL slug, and internal/external link distribution audited.

Technical SEO. Core Web Vitals diagnosis, schema markup validation, mobile responsiveness, crawl errors, and duplicate content detection, surfaced as a prioritized fix list.

Content coverage. Comparison against top-ranking competitors for the target keyword. What are they covering that you're not? Which subheadings appear across all of them but are missing from yours?

The output is a concrete optimization checklist: not a score, not a color-coded dashboard, but a list of specific changes with before/after examples. This is the piece that converts "I wrote a good article" into "my good article actually ranks for its target keyword."

The AI Overview factor. One meaningful shift: Google's AI Overviews increasingly answer queries at the top of the SERP, and the articles that get cited in those overviews are structured differently from articles that just rank. Short, direct answers to the query early in the article. Clear entity definitions. Explicit comparisons. Good AI optimization surfaces this structural layer explicitly, flagging whether your article is shaped to be citable, not just rankable.

Phase 4: Authority Building and Link Acquisition

On-page SEO gets you into the ranking conversation. Domain authority decides whether you stay there. If your DA is 25 and your competitors are at 60, even perfect on-page optimization will stall somewhere on page two. Link building is the levee that keeps the rest of your SEO work from washing away.

AI handles this layer by reverse-engineering the backlink profiles of your top competitors, identifying the referring domains linking to them but not to you, and producing a prioritized outreach plan with personalized templates per prospect type.

"Build a link-building strategy to grow our DA from 32 to 50 over the next six months. Analyze backlink profiles of our top 3 competitors, find link gaps, and generate personalized outreach templates for bloggers, journalists, and resource-page curators."

What you get back is a monthly link-building calendar with targets, a prospect list segmented by outreach archetype, and personalized email templates that don't read like mass outreach. Combined with the content planner, this closes a classic SEO loop: the content you're writing becomes the link-bait the authority builder is pitching.

Phase 5: Rank Tracking and Iteration

SEO work has a brutal feedback delay. You publish an article, wait 8 to 12 weeks, and then find out whether the strategy worked. The only way to stay efficient is a tight measurement loop: rankings monitored weekly, traffic attributed to clusters, and the editorial calendar iterated based on what's actually moving.

The diagnostic loop is what separates SEO programs that compound from ones that churn:

Track weekly. Ranking movement for every target keyword, plus Core Web Vitals and indexation status.

Review monthly. Which clusters are gaining traction? Which are stuck? Which articles are close to page one and need a push?

Iterate quarterly. Reprioritize the editorial calendar based on what's working. Double down on winning clusters. Shelve the ones that aren't gaining traction.

Putting It Together: A 90-Day AI SEO Plan

Here's how a small team (or a solo founder) uses these phases in sequence over a single quarter:

Weeks 1 to 2: Research. Run gap analysis on your niche. Identify the 20 to 30 highest-intensity pain points your audience is discussing. Feed those into the content planner for keyword expansion and clustering.

Week 3: Planning. Finalize the topic cluster map and 12-week editorial calendar. Prioritize the three clusters with the best intent-intensity-competition profile.

Weeks 4 to 11: Execution. Write and publish 1 to 2 articles per week. Run each draft through on-page optimization before publishing. In parallel, start monthly outreach campaigns using the published articles as link-bait.

Week 12: Review and iterate. Pull rank tracking data. Identify which clusters are gaining traction. Re-prioritize next quarter's calendar. Rinse and repeat.

The compounding effect is real. Each quarter, the editorial calendar gets smarter because it's informed by what actually ranked the previous quarter. Outreach compounds because each published article becomes another link-bait asset. And the cluster structure means every article boosts the ones around it through internal linking.

Common Questions

"Does AI-generated content rank?"

Yes, if it's good. Google's guidance is explicit that the origin of content doesn't matter; the quality, helpfulness, and E-E-A-T signals do. AI-generated slop doesn't rank. AI-assisted content with human editing, domain expertise, and original insight ranks the same as any other good content.

"Do I still need Ahrefs / SEMrush?"

Probably yes, for keyword volume and difficulty data. AI doesn't replace the underlying SEO databases. It replaces the workflow layer on top of those databases. Use your existing tool for raw data. Use AI for the analysis and planning that normally takes days of manual work.

"How soon should I expect results?"

For a new site or niche, meaningful ranking movement usually takes 3 to 6 months. For an established site adding to an existing topic cluster, 6 to 12 weeks is realistic. AI doesn't shorten Google's indexation and trust timelines. It shortens the planning and execution time that sits on top of them.

"What about AI Overviews cannibalizing clicks?"

Real issue, no way around it. The answer is to optimize for both ranking and citation-worthiness: short, direct answers near the top, clear entity definitions, explicit comparisons. Articles that get cited in AI Overviews capture authority and referral traffic even when the direct CTR drops.

Getting Started

You don't have to run the whole system on day one. Each phase delivers value independently. If you're not sure where to start, begin with gap analysis. It's the cheapest way to find out whether you're chasing the right topics before investing in the rest of the pipeline.

I publish free playbooks for every phase of this workflow at claudecodehq.com: content gap finding, topic cluster planning, on-page optimization, authority building, and rank tracking. Each one is a ready-to-use template you can drop into a project and start running immediately.

SEO has always rewarded teams that could execute consistently. The difference in 2026 is that execution is no longer the bottleneck. Strategy is. Build the loop once, and every quarter compounds on the last.

Originally published on claudecodehq.com

I Automated My Entire Invoicing Workflow With AI. Here's the Playbook.

Daniel Marin — Tue, 21 Apr 2026 19:00:12 +0000

How I went from losing Friday afternoons to invoice admin to a system that generates, sends, tracks, and reconciles invoices without me touching them.

If you run a small business, freelance, or manage AP/AR for a growing team, you already know the shape of the problem. Invoicing isn't hard. It's just endless. You create the invoice in one tool, email it from another, track whether it got paid in a spreadsheet, reconcile the payment against your bank feed, and categorize it in your accounting software.

One invoice takes twenty minutes. Fifty invoices a month is a part-time job. And nobody ever got into business because they loved chasing overdue receivables.

The good news: invoice processing is almost perfectly shaped for AI automation. The work is rule-based, the data is structured, and the decisions are mechanical. This guide walks through how to automate it end to end. Most teams that implement this report saving 10+ hours a week. Some save considerably more.

Where Your Invoicing Hours Actually Go

Before automating anything, it helps to audit where the time goes. For most businesses processing 30 to 100 invoices per month, the breakdown looks remarkably similar:

Creation (2 to 4 hours/week). Copying line items from project notes, looking up tax rates, calculating totals, formatting the PDF.

Sending and follow-up (2 to 3 hours/week). Emailing invoices, writing polite reminders at 30/60/90 days, answering "can you resend last month's invoice?"

Reconciliation (3 to 4 hours/week). Matching incoming payments to invoices, handling partial payments, marking things paid in the accounting system, chasing the ones that don't match.

Organization (1 to 2 hours/week). Filing received invoices from vendors, naming them consistently, storing them somewhere your accountant can find at tax time.

Add it up: 8 to 13 hours per week of high-skill staff time spent on work that requires almost no judgment. For a business owner who's also the salesperson, product manager, and customer support, that's the difference between growing and treading water.

The Three-Layer Automation Stack

Effective invoice automation isn't one monolithic tool. It's three layers that work together. You can implement them individually or in sequence, and each one pays for itself on its own.

Layer 1: Generation. Turn a natural-language description into a properly formatted, tax-calculated, professionally branded invoice PDF in seconds, not minutes.

Layer 2: End-to-end workflow. Send the invoice, track its status, auto-remind at 30/60/90 days, mark it paid when the payment lands, and sync everything to your accounting system.

Layer 3: Organization. Categorize inbound invoices from vendors, file them consistently, track payment status, and produce audit-ready archives at tax time.

Layer 1: Generate Invoices in Seconds

The fastest visible win is invoice creation. Most small businesses are still building invoices in Word or Google Docs, copying last month's file, overwriting the details, recalculating the tax by hand, and exporting to PDF. It takes 15 to 20 minutes per invoice when things go smoothly. Multi-currency or line-item-heavy invoices take much longer.

With AI, you describe the invoice in plain English and get back a fully formatted PDF:

"Generate an invoice for 40 hours of consulting at $150/hr for Acme Corp, plus $500 for the strategy deck. 10% GST. Net 30. Use the EUR template since they're Berlin-based."

The output is a proper PDF with itemized line items, correctly calculated tax, your payment terms, and bank details in the right format for the client's country. Multi-currency is handled natively. Sequential numbering picks up from your last invoice. And because the system understands invoice conventions, you don't have to remember whether VAT goes on the subtotal or the total.

Where generation alone saves time:

20 minutes to 20 seconds per invoice
No more duplicate invoice numbers
Tax calculated correctly on the first try, including multi-rate situations
Consistent branding across every invoice without template drift
International clients get the currency and format they expect

Layer 2: Automate the Full Send-Track-Reconcile Cycle

Creating invoices is the visible work. The invisible work (the part that actually eats your week) is everything that happens after the PDF exists. Emailing it to the client. Remembering to follow up 30 days later. Answering "did you send it to the right address?" Matching the incoming wire to the right invoice. Marking it paid in QuickBooks.

This is where the hours disappear.

Full lifecycle automation handles all of it:

"When a project is marked complete in my project tracker, generate the invoice from the time entries, email it to the client with a Stripe payment link, remind them at 30/60/90 days if unpaid, and mark it paid in QuickBooks once Stripe confirms payment."

Here's what that looks like in practice:

Triggered generation. When the upstream event happens (project complete, milestone hit, month-end), the invoice generates automatically from the underlying data. No manual handoff.
Send with payment link. Invoice goes out by email with a Stripe, PayPal, or bank transfer link embedded, tracked with delivery confirmation.
Staged follow-ups. Gentle reminder at 30 days, firmer at 60, escalation at 90. With the tone you'd use if you were writing each one by hand.
Payment detection. When the Stripe webhook fires or the bank deposit clears, the invoice gets marked paid automatically.
Accounting sync. QuickBooks, Xero, or your platform of choice gets the invoice and payment record without you opening it.

Before: Friday afternoon is invoice day. Two hours generating invoices from timesheets, another hour emailing them, then Monday morning you realize you forgot to follow up on the three invoices from last month that are now 45 days overdue.

After: Invoices generate and send themselves when projects close. Reminders go out on schedule. Payments reconcile automatically. Your Friday afternoon is spent on work that actually grows the business.

Layer 3: Organize the Inbound Side (The Receipts Problem)

Outbound invoices are half the story. The other half: the invoices you receive from vendors, SaaS subscriptions, contractors, that one Uber ride that was actually a business expense. These show up in email attachments, get forwarded to a Drive folder, and then six months later your accountant asks for "the invoice from that AWS bill in March" and you spend 20 minutes searching.

AI solves the file-chaos problem:

"Organize my 2026 invoices folder. Rename everything by date-vendor-invoice-number, categorize by expense type, flag anything still unpaid, and give me a vendor summary with totals."

You get back: a folder of consistently named PDFs (2026-03-Acme-INV0042.pdf), a spreadsheet with vendor, date, amount, category, and payment status, and a summary report that tells you exactly where your money went by category. Come tax time, your accountant gets a clean export instead of a Drive folder named "receipts_2026_v3_FINAL."

A Realistic 30-Day Rollout

You don't need to automate everything at once. Each step compounds into the next:

Week 1: Stand up generation. Set up your branding and start creating outbound invoices with AI. Immediate time savings from day one.

Week 2: Add the send-and-track layer. Wire up email and your payment provider. Start with one client workflow to validate the end-to-end flow.

Week 3: Expand to all clients. Once the workflow is proven, roll it out across all your outbound invoicing. Shut off the Friday-afternoon-invoice-day ritual.

Week 4: Clean up the inbound side. Run the organizer across your vendor invoice folder, establish an intake routine, and hand your accountant a clean archive.

By the end of month one, most businesses report reclaiming 8 to 15 hours per week. Days that used to end with "I still need to send those invoices" end with the invoices already sent, reminders already scheduled, and last month's payments already reconciled.

Common Questions

"What if I already use QuickBooks / Xero / FreshBooks?"

These workflows work alongside existing accounting software, not instead of it. What gets replaced is the manual work between the accounting software and everything else: generating the invoice, emailing it, chasing the payment, and reconciling it.

"Is AI reliable enough for money?"

The calculations are deterministic. No "the AI made up a number." Tax rates come from tables you configure, amounts come from structured source data (time entries, contracts, line items you provide), and totals are computed arithmetically. The AI's job is orchestration, not arithmetic.

"Can I customize the reminder emails?"

Yes. You provide templates or tone guidance, and the system adapts. A polite first-reminder tone at 30 days, firmer at 60, and an escalation path at 90. Each in your voice, with your signature, not a robotic "PAYMENT OVERDUE" template.

"Is my financial data safe?"

Claude Code runs locally. Your invoice data, client details, and payment records stay on your machine unless you explicitly connect them to external services (Stripe, QuickBooks, Gmail) that you're already using. This is materially different from SaaS invoicing tools that store all your client data on their servers.

Getting Started

The first time you watch an invoice generate, send, and reconcile itself without you touching it, you'll wonder why you spent so many Friday afternoons on this. The tenth time, when you realize you haven't chased an overdue payment all month because they're all paid, is when it stops feeling like automation and starts feeling like operating leverage.

I publish free, ready-to-use playbooks for all three layers (generation, full lifecycle automation, and inbound organization) at claudecodehq.com. If you're not sure where to begin, start with the invoice generator. Fastest win, visible results from the first invoice, and it sets up the data shape the automation layer uses later.

Originally published on claudecodehq.com

I Stopped Reading 40-Page Contracts From Scratch. Here's the AI Workflow I Use Instead.

Daniel Marin — Mon, 20 Apr 2026 18:28:26 +0000

How to analyze legal documents in minutes, flag risky clauses, redline against your standard terms, and run bulk due diligence across hundreds of contracts.

Nobody signs a contract hoping to read it. You skim the first page, glance at the payment terms, check who gets to terminate, and hope the middle twenty pages of boilerplate don't contain a landmine.

Real review (the kind where you catch the auto-renewal, the unlimited indemnity, the IP assignment buried in the appendix) takes hours per document. For most people, that cost is steep enough that the review simply doesn't happen.

This is exactly the pain AI contract review was built for. Modern AI can read a 40-page agreement in under a minute, flag risky clauses with severity ratings, compare it against your standard terms, and produce a redline your lawyer can sanity-check in ten minutes instead of building from scratch in three hours.

Here's how it works, what to expect, and what to watch out for.

Why Manual Contract Review Is Broken

A typical mid-size business signs dozens of contracts a month: NDAs, vendor MSAs, employment agreements, SaaS subscriptions, consulting SOWs. Hiring outside counsel to review each one at $400 to $800 per document isn't tenable. Asking in-house counsel to do first-pass redlines turns them into a bottleneck. Skipping review is the default, and it's the option that quietly costs the most.

Before: A 40-page vendor contract lands in your inbox on Friday. Legal is booked for two weeks. You either delay the deal, sign it as-is, or spend three hours reading it yourself and hope you spotted the worst clauses.

After: You drop the contract into a folder, ask AI to review it, and get a clause-by-clause risk analysis with severity ratings in under two minutes. You forward the high-risk items to legal with specific questions. A 15-minute review instead of three hours.

AI doesn't replace your lawyer. It replaces the first hour of every review: the mechanical reading, the clause-by-clause classification, the comparison against a known good template. So that when a lawyer finally looks at the document, they're reviewing your concerns, not starting from page one.

The Three Contract Review Workflows That Actually Save Time

"Using AI for contracts" isn't one workflow. It's three distinct patterns, each solving a different problem.

1. Single-Contract Risk Analysis

The most common case: you have one contract in front of you and need to know whether signing it is safe. You're not comparing it to anything. You just want to know whether the indemnity is reasonable, whether the termination clause is one-sided, and whether there's a surprise auto-renewal.

Drop in the contract, and the AI walks through every major clause (liability, IP, termination, payment, governing law, non-compete) and flags anything outside of market norms with a severity rating. Missing provisions are surfaced too: no limitation of liability, no termination for convenience, no arbitration clause.

A prompt like this works well:

"Review this freelancer service agreement for risks. I'm the client, based in Delaware, and the contractor is overseas."

The output is a structured report: each clause labeled, risk level assigned (low, medium, high, critical), a plain-English explanation of why it matters, and a specific recommendation. Either proposed language, a clarifying question, or "flag for lawyer." It's the kind of first pass a junior associate would produce, except it arrives in ninety seconds.

2. Redlining Against Your Standard Terms

If your company has a standard MSA, NDA, or services agreement, the real question isn't "is this contract risky?" It's "how does this vendor's paper deviate from ours?"

That's a comparison task, and it's where traditional review gets mind-numbing: scanning side-by-side for every changed word.

AI takes your approved templates and compares the counterparty's draft against them. Every deviation is flagged. Not just word changes, but substantive shifts: a cap on liability that's been removed, a jurisdiction clause that's been swapped, or a payment term that's quietly gone from Net 30 to Net 60.

"Redline this vendor's MSA against our standard template. Flag anything that weakens our position and suggest counter-language."

For each deviation, you get three things: what changed, why it matters, and proposed alternative language drawn from your own template. The document that comes back to your lawyer is already organized by severity. They're making judgment calls, not hunting for differences.

This is where in-house counsel and procurement teams see the biggest lift. Weeks of backlog collapse into days.

3. Bulk Contract Analysis and Due Diligence

M&A due diligence, vendor portfolio reviews, and compliance audits all share the same shape: dozens or hundreds of contracts that individually matter a little but collectively matter a lot.

You need to know which agreements have change-of-control clauses, which auto-renew, which contain MFN pricing, and which have unusual indemnity provisions. Across the whole portfolio, not one at a time.

"Review all 150 vendor contracts in this folder. Extract termination, liability, IP, and auto-renewal terms. Flag any that have change-of-control provisions or MFN pricing. Summarize the 10 highest-risk agreements."

The output is a searchable database: every contract normalized against the same schema, so you can sort by counterparty, filter by risk level, or pull up every agreement with a specific clause type. For deal teams racing against a diligence deadline, this is the difference between making the close and missing it.

What AI Catches (and What It Doesn't)

It's worth being clear-eyed about strengths and limits.

Where AI excels:

Consistency. AI reviews clause 14 with the same attention it gave clause 2. Humans get tired. AI doesn't.
Pattern recognition. Unlimited indemnities, one-sided termination, buried auto-renewals, IP assignment creep: these show up in predictable ways, and AI spots them reliably.
Cross-document comparison. "How does this differ from our standard?" is a task where AI is dramatically faster and less prone to miss small-but-material word changes.
Structured extraction. Pulling termination dates, renewal terms, payment schedules, and governing law out of 100 contracts into a spreadsheet is exactly the work AI was built for.

The honest limits:

Jurisdiction-specific nuance. A clause that looks fine might be unenforceable under Delaware law or too restrictive under California labor code. AI can surface the question. A qualified lawyer answers it.
Deal-specific strategy. Whether you should push back on a term depends on leverage, relationship, and context AI doesn't have. It flags the risk. You decide what to do.
Novel or creative provisions. Unusual clauses that don't match any standard pattern are harder for AI to evaluate. High-stakes or non-standard contracts still warrant human review.

The framing that works: AI contract review is not a substitute for legal counsel. It's a multiplier on it. A lawyer who spends fifteen minutes on a pre-analyzed contract delivers more value than the same lawyer spending three hours on a cold read.

A Realistic End-to-End Workflow

Here's how a small business or in-house legal team actually uses this in practice:

Intake. Any new contract (inbound or outbound) goes into a shared folder with a consistent naming convention.
First pass with AI. Run risk analysis for standalone review, or redlining if you have a matching template to compare against.
Triage. Low-risk contracts with no significant flags get signed. Medium-risk contracts get negotiated using the AI-suggested counter-language. High-risk contracts escalate to counsel with a focused list of concerns.
Lawyer review. Counsel reviews the AI analysis, validates the high-risk findings, and handles the judgment calls. Because they're starting from a structured report, not a blank page, review time drops by 60 to 80%.
Archive. Signed contracts go into a tracked portfolio. Every quarter, run bulk analysis to surface renewal dates, concentrations of risk, and clauses that need to be renegotiated at renewal.

The compounding benefit shows up over months. A company reviewing 50 contracts a month used to have two states: everything reviewed carefully but slowly, or everything signed quickly but blindly. With AI in the loop, every contract gets a real first-pass review, and the contracts that deserve deeper scrutiny actually get it.

Common Questions

"Can I actually rely on AI to catch the bad clauses?"

For standard commercial contracts (NDAs, MSAs, service agreements, employment contracts, vendor deals), yes, for the common patterns. The AI reliably flags the usual landmines: unlimited liability, auto-renewal without notice, one-sided termination, IP assignment creep, jurisdictional surprises. For anything high-stakes or genuinely unusual, treat AI as a strong first pass and keep a lawyer in the loop.

"Is my contract data secure?"

Claude Code runs locally on your machine. Contracts stay on your computer. They aren't stored or used to train models. For regulated industries or deal work involving material non-public information, this is a meaningful difference from browser-based tools that upload documents to a shared server.

"What file formats does it handle?"

PDF, DOCX, and plain text work out of the box. Scanned PDFs need to be OCR'd first, but that's a one-step preprocessing task that can be handled in the same session.

"Will this replace lawyers?"

No. And anyone selling you that story is selling you a lawsuit. It replaces the mechanical, repetitive parts of contract review. Legal judgment, negotiation strategy, and jurisdiction-specific advice still require a human lawyer. What changes is the ratio: lawyers spend more time on judgment, less on reading.

Getting Started

The first time you watch a 40-page vendor contract get reviewed in ninety seconds, the value is obvious. The second time, when you're running bulk diligence on a hundred agreements before a Monday deadline, it stops being a productivity tool and starts being infrastructure.

I publish free, ready-to-use playbooks for all three workflows (single-contract risk analysis, redlining against your templates, and bulk due diligence) at claudecodehq.com. Drop one into a project folder, point it at your contract, and you'll have a structured risk analysis before your coffee finishes brewing.

Originally published on claudecodehq.com

I Used AI to Build a DCF, an LBO, and a 3-Statement Model. Here's What Actually Worked.

Daniel Marin — Sun, 19 Apr 2026 08:28:30 +0000

A practical guide for finance professionals who want to stop spending eight hours on cell linking and start spending that time on judgment calls.

Financial modeling is one of those disciplines where the thinking matters enormously but the execution is largely mechanical. You spend ten minutes deciding the right revenue growth assumption, then two hours wiring it through three linked statements, checking that the balance sheet balances, and formatting the output tab.

That ratio (high-judgment decisions surrounded by low-judgment plumbing) is exactly where AI delivers the most leverage.

This guide walks through how to use AI to build the three financial models that matter most in corporate finance and investment banking: DCF valuations, LBO models, and fully linked 3-statement models. The goal isn't to replace your judgment. It's to eliminate the hours of mechanical work around it.

Why Finance Professionals Are Starting to Use AI for Modeling

If you work in IB, PE, or FP&A, you already know the pain. A single DCF model can take 4 to 8 hours to build from scratch. An LBO model with multiple scenarios can take a full day. And when the MD walks in with "can you run this with 200bps higher WACC and show me the sensitivity table by tomorrow morning," you're not leaving the office.

AI doesn't change the finance. The models, the formulas, the accounting relationships are all the same. What it changes is who does the typing.

Before: You decide on assumptions, then spend hours linking cells, building schedules, formatting output. One circular reference and you're debugging for 45 minutes.

After: You describe the model structure and assumptions in plain English. AI generates the linked model, builds the schedules, and produces the output tabs. You review, adjust assumptions, and re-run. Total time: under an hour.

Crucially, the output isn't a black box. The AI generates the actual formulas and logic in a format you can inspect, audit, and modify. You stay in control of every assumption.

1. DCF Valuation: From Assumptions to Enterprise Value

The DCF is the foundation of intrinsic valuation. The model itself isn't complicated: project free cash flows, discount them back, add terminal value. The time sink is building the supporting schedules, linking revenue drivers through the income statement, computing unlevered FCF correctly, and formatting a clean output with a sensitivity table.

With an AI coding agent, you describe what you need and let it build the structure:

"Build a 10-year DCF for a SaaS company. Revenue is $50M growing at 25% declining to 15% by year 5. EBITDA margin expands from 20% to 35%. CapEx is 5% of revenue. WACC is 10%. Terminal growth rate is 3%. Include a sensitivity table on WACC and terminal growth."

The AI generates the full model: revenue build, operating expenses, EBITDA, D&A schedule, tax computation, unlevered FCF, discounting, terminal value (both perpetuity growth and exit multiple), bridge to equity value, and the sensitivity table. Every formula is visible and auditable.

Where AI saves the most time in DCF work:

Building the revenue bridge (bottoms-up with multiple drivers vs. top-line growth)
Linking D&A, CapEx, and NWC schedules to the income statement and balance sheet
Computing UFCF correctly (the conversion from EBITDA to unlevered FCF is where most manual errors happen)
Generating sensitivity and scenario tables across multiple assumption combinations
Reformatting an existing model when the MD wants "a different layout" at 11 PM

2. LBO Modeling: Leverage, Returns, and Scenario Analysis

LBO models are where complexity compounds. You have the operating model, then layered on top: a sources and uses table, a debt schedule with multiple tranches, mandatory and optional repayments, cash sweeps, PIK toggles, and returns analysis at various exit years and multiples. Each piece links to the others in ways that are easy to get subtly wrong.

The time-killing steps aren't the conceptual ones. They're the mechanical ones:

Debt waterfall. Building a multi-tranche debt schedule where senior debt is repaid first, then sub-debt, with different rates, amortization schedules, and optional prepayment logic. Getting the cash flow cascade right is a 90-minute exercise in careful cell linking.

Returns analysis. Computing IRR and MOIC at multiple exit years and exit multiples, then displaying it in a clean matrix. Simple in concept; tedious in Excel.

Scenario toggles. Base, upside, and downside cases that flow through the entire model. One mislinked cell and the downside case shows better returns than the base. That's the kind of error that surfaces in the IC meeting.

Here's what a prompt looks like for this kind of model:

"Build an LBO model. Purchase price 8x EBITDA on $100M LTM EBITDA. 5x senior at L+400 with 1% amort, 2x sub-debt at 10% PIK. Management rolls 10% equity. Revenue grows 8% declining to 5%. EBITDA margin stable at 30%. Exit in years 3 to 5 at 7x to 9x. Show IRR and MOIC matrix."

The payoff is sharpest when assumptions change. In a traditional workflow, re-running an LBO with different leverage or pricing takes 30 to 60 minutes of careful re-linking. With AI, you change the assumptions in the prompt and regenerate. The entire debt waterfall, returns table, and scenario matrix update in one pass.

3. Linked 3-Statement Models: The Foundation of Everything

Every DCF and LBO rests on a 3-statement model. The income statement, balance sheet, and cash flow statement must link perfectly. Net income flows to retained earnings, depreciation adds back in cash flow, changes in working capital reflect on both the balance sheet and cash flow statement. The balance sheet must balance.

This is the model type where AI assistance has the highest ROI, because it's also the one with the highest error rate. The classic mistakes (a sign flip in working capital, CapEx flowing as positive instead of negative, the cash balance not reconciling) happen because humans lose track of linkages across 200+ cells. An AI that generates the full structure in one pass doesn't have that problem.

The prompt is straightforward:

"Build a 3-statement model from this company's last 3 years of financials. Project 5 years forward. Revenue grows at 12%. Gross margin improves 50bps per year. SG&A as % of revenue declines from 30% to 25%. CapEx is 8% of revenue. D&A is tied to the PP&E schedule. Working capital ratios held constant."

The model links all three statements, builds supporting schedules (debt, depreciation, working capital), and includes a balance sheet check that flags if anything is out of balance. If you need to layer a DCF or LBO on top, the 3-statement model becomes the operating model input. You're building Lego blocks, not monoliths.

The Real Workflow: How Finance Teams Use This Day to Day

In practice, most analysts and associates don't use AI to build models from scratch every time. The more common pattern is:

Generate a first draft with the deal or company's key assumptions.
Review and adjust: swap in more nuanced assumptions, add company-specific line items, refine the revenue build.
Run scenarios: generate base/upside/downside cases, or sensitivity tables across multiple variables.
Audit the model: check for circular references, unlinked cells, sign errors, and balance sheet imbalances.
Format for presentation: standardize colors, number formats, tab layout, and add a cover page and assumptions summary.

Steps 1, 3, 4, and 5 are almost entirely automatable. Step 2 is where your expertise lives, and where you should be spending your time. The net effect: a model that took a full day now takes 1 to 2 hours, and most of that time is judgment, not formula entry.

Common Concerns (and Honest Answers)

"Can I trust an AI-generated model?"

You should review it exactly as you'd review a model built by a first-year analyst. The logic is transparent. Every formula is visible, every assumption is labeled. The difference is that AI doesn't make typos or forget to link a cell. The errors it does make tend to be structural (wrong methodology, not wrong formula), which are easier to catch in review.

"Will this work with Excel?"

Yes. The output is structured data with clear formulas, not opaque code. You can open it directly in Excel or Google Sheets and modify any cell after generation exactly as you would in a hand-built model.

"Is my data secure?"

Claude Code runs locally on your machine. Your financial data, assumptions, and model outputs don't leave your environment unless you explicitly send them somewhere. This matters for deal teams working with material non-public information.

"Will this replace analysts?"

No. It replaces the mechanical parts of an analyst's job, the same parts that analysts themselves wish they didn't have to do. The judgment, the client communication, the deal structuring: that's still human work. AI just means fewer all-nighters reformatting the same model for the third time.

Getting Started

Start with whichever model you build most often. The first time you watch AI generate a linked 3-statement model with a working balance sheet check in under five minutes, the ROI becomes obvious. The second time, when the MD changes the assumptions at midnight and you regenerate in sixty seconds, it becomes indispensable.

I publish free playbooks for each of these model types (DCF, LBO, 3-statement, and more) at claudecodehq.com. Each one gives you a ready-made template you can drop into a project folder and start prompting against immediately. Worth a look if you want to cut your modeling time by 80% without changing your methodology.

Originally published on claudecodehq.com