Step 01: Start With Context, Not Code
Idea Browser now connects directly to Claude Code as an MCP. That means an AI agent can pull project context — ICP, positioning, competitive landscape, growth strategy — without anyone pasting walls of text into a terminal.
For the demo, Amir opened a project he and Jordan had already scoped: an AI sparring partner for B2B sales teams, niched into freight software. The tool already had an offer definition file covering target customer, transformation, value, and competitive positioning.
Why this matters
Most people start by prompting “build me a landing page for X.” They get a generic page because the AI has zero context about the business.
Idea Browser stores that context as files you can reference across sessions. When it is connected as an MCP, Claude Code reads the full project history before writing a single line of copy.
The biggest problem right now: everyone can build landing pages and everyone has ideas. The gap is knowing where to find customers and having the confidence that the idea is worth pursuing. Context-first planning closes that gap.
Step 02: Use Skills to Build the Right Asset
Idea Browser includes “skills” — specialized prompt templates for specific business tasks. Amir used two: Lead Magnet Legend (to create a lead capture offer) and Landing Page Architect (to structure the page).
The Lead Magnet Legend skill analyzed the freight software niche and produced a specific concept: “5 Objections That Kill Freight Software Deals.” It saved the concept as a file inside the project, so every future prompt has that context baked in.
Prompt: Connect to Idea Browser MCP. Look at my AI B2B sparring partner project. Pull the right context. Then use the Lead Magnet Legend skill to create a lead magnet landing page.
One prompt. The agent reads the project, selects the skill, generates the asset, and stores the output for the next step.
Step 03: Design in Paper (Not in Code)
This is where most vibe-coded projects fall apart. Founders iterate directly in code, lose track of versions, and end up with a page that looks like a developer built it at 2 a.m.
Paper changes that. It connects to Claude Code and gives you an actual design interface where you create visual iterations before writing production code. Think of it as Figma, but the AI agent can read the design and build from it directly.
The workflow
Open Paper. Create a component — hero section, testimonial block, pricing card. Iterate on the visual direction. When a version feels right, Claude Code reads the design and builds the real page from it.
Amir refined hero sections, swapped layouts, and tested different visual hierarchies before a single line of production code was written. The result: a landing page that looks designed, not coded. Professional typography, intentional spacing, real visual hierarchy.
Step 04: Track Everything With Humblytics
Once the page is live, Humblytics handles the analytics layer. Standard traffic data, channel attribution, heatmaps for scroll depth and click tracking, and full funnel visualization.
If paid campaigns are in play (Meta, Google), Humblytics connects directly and gives back revenue attribution per channel. You see exactly what ad spend is making money.
What you get out of the box
- Traffic sources and visitor data
- Scroll depth heatmaps showing where people drop off
- Click maps showing what elements get attention
- Funnel tracking (page visit to guide download, for example)
- Full ad campaign attribution
Step 05: Run A/B Experiments From the Terminal
This is where the stack gets wild.
Amir used Claude Code to hit the Humblytics API and create an A/B experiment directly from the terminal. No code deploy. The Humblytics script dynamically updates the page content, so the variant shows up live without pushing changes through a developer.
Prompt: Using the Humblytics API, create an A/B experiment (no-code type) for the headline on this landing page.
Within seconds, the experiment was live. The control headline stayed in place. The variant rotated in automatically for a split of the traffic. Humblytics tracked conversions, clicks, and engagement for both versions in real time.
The variant it generated: “Every lost deal started with an objection your rep wasn’t ready for.”
Amir’s reaction: “Honestly, not bad. Pretty fire.”
Humblytics also has a recommendations endpoint. Point an agent at it, and it scrapes the site, pulls traffic insights, reads existing analytics data, and returns a detailed report on what to test and where to focus. The experiments write themselves.
Step 06: Compound Context Over Time
The final layer: feed results back into Idea Browser.
After each experiment, add the performance data — what headline won, what converted, where traffic came from — into the project context. The next time an agent is prompted for a landing page, a growth strategy, or a new lead magnet, it has historical performance data baked in.
Amir’s team does this with a master performance log. Every A/B test result, every revenue figure, every optimization gets stored. When they spin up the next campaign, the AI starts from real data instead of guessing.
“If you have that context compounding over time, you’re just going to get better results. That’s how you compete.” — Amir
Step 07: Close The Loop With Agentic Social Distribution
A tested landing page only matters if people see it. The traditional bottleneck — writing, formatting, scheduling posts across X, LinkedIn, Reddit, Instagram, Threads, TikTok, YouTube, and the rest — is exactly the kind of task that breaks the agentic flow the moment you leave the terminal.
That’s where Postiz slots in. It exposes the same MCP and public API surface that Idea Browser and Humblytics do, which means Claude Code can schedule and publish content across 32+ channels without a dashboard, a copy-paste step, or a second human.
Connect Postiz as an MCP
Grab an API key from Settings → Developers → Public API in Postiz, then point Claude Code at the MCP endpoint:
URL: https://api.postiz.com/mcp
Authorization: Bearer your-api-key
Once connected, the agent gets eight tools out of the box: integrationList, integrationSchema, triggerTool, schedulePostTool, generateImageTool, generateVideoOptions, videoFunctionTool, and generateVideoTool. The agent discovers the schema, learns per-platform rules (X character limits, Reddit flairs, TikTok privacy flags, Pinterest boards), and drafts platform-native posts automatically.
The one-prompt distribution layer
A natural extension of the workflow above looks like this:
Prompt: Using the Postiz MCP, take the landing page we just shipped for the freight sales sparring partner. Draft a teaser for X, a long-form breakdown for LinkedIn, a soft-promote post for r/sales, and a vertical video script for TikTok. Schedule everything for peak time in PST tomorrow.
Claude Code calls integrationList to discover the connected accounts, integrationSchema per platform to learn the rules, generateImageTool or generateVideoTool if a visual is needed, and schedulePostTool to ship everything into the queue. The same terminal, the same session, a whole distribution calendar.
Or hit the public API directly
If you prefer raw HTTP from an automation (n8n, Make, a cron job, your own agent), Postiz exposes a clean REST surface:
curl -X POST "https://api.postiz.com/public/v1/posts" \
-H "Authorization: your-api-key" \
-H "Content-Type: application/json" \
-d '{
"type": "schedule",
"date": "2026-04-20T15:00:00.000Z",
"shortLink": false,
"tags": [],
"posts": [{
"integration": { "id": "your-x-integration-id" },
"value": [{
"content": "Every lost deal started with an objection your rep wasn't ready for. Free guide:",
"image": []
}],
"settings": {
"__type": "x",
"who_can_reply_post": "everyone"
}
}]
}'
One endpoint, 32 platforms, platform-specific settings baked into the __type field. That includes Medium, Dev.to, Hashnode, and WordPress for blog syndication, plus Discord, Slack, Telegram, and Listmonk for community and newsletter blasts.
Feed performance back into the loop
Postiz also exposes analytics endpoints per integration and per post. Pipe those numbers back into Idea Browser alongside the Humblytics results and the context compounds further: now the next campaign knows which headline converted and which distribution channel drove the traffic that converted. The agent stops guessing about paid spend and organic reach in the same breath.
The Opportunity: This Stack Is the New Arbitrage
Facebook ads used to cost 5 cents a click. Amir remembers it. He was paying $0.05 per click and charging companies $2 per install. The margin was absurd because almost nobody knew the platform existed yet.
Today, average CPC sits around $2-3. That window closed because everyone caught up.
The same window is open right now with this tooling. 99.999% of people (Amir’s number) have never seen this stack. They are still building landing pages manually, guessing at headlines, waiting weeks for analytics data, and copy-pasting the launch into six different social dashboards. You can go from raw idea to live A/B experiment plus a fully scheduled multi-channel launch in a single session.
There is also a services play here. Amir mentioned customers paying $5K-$10K/month for his team to run this exact workflow on their behalf: connect ad platforms, get full attribution, optimize landing pages, and report back on where top-of-funnel spend should go. Add agentic social distribution on top of that retainer and the margins look a lot like 2012 Facebook ads.
Action Checklist
- Set up Idea Browser and connect it to Claude Code as an MCP.
- Create a project with your ICP, positioning, and offer definition.
- Use a skill (Lead Magnet Legend or Landing Page Architect) to generate your first asset.
- Open Paper and design your landing page components before building in code.
- Install Humblytics on your live page for traffic, heatmaps, and funnel tracking.
- Run your first A/B experiment from the terminal using the Humblytics API.
- Connect Postiz as an MCP and schedule a multi-channel launch from the same session.
- Log both experiment results and social performance back into Idea Browser so context compounds.
Final Thought: Context Compounds. Tools Multiply.
The stack works because each tool feeds the next. Idea Browser holds the context. Paper refines the design. Claude Code builds the page. Humblytics runs the experiment. Postiz distributes the result. And every data point — conversion, click, share, comment — flows back into Idea Browser for the next cycle.
One session. One terminal. A live, tested, conversion-tracked landing page with a full social launch schedule behind it. No designer. No developer. No guessing.
“99.999% of people don’t know that this stack exists. And there’s an opportunity to create offers and arbitrage right now.” — Greg Isenberg
Ready to Plug Distribution Into Your Agentic Stack?
The part most founders skip — because it’s the most painful by hand — is the social distribution layer. Postiz fixes that at the MCP and API level, so your agent can ship the launch the moment the page goes live.
You can schedule across 32+ channels, generate AI images and videos for each platform, track analytics per integration, and wire it all into Claude Code, n8n, Make, or Zapier without a single browser tab.
Try Postiz free at postiz.com and let your agent run the distribution layer for you.
