03 · Apps · Workflows · Frontends
Three phases, one toolkit, a token economy that decides between success and money pit. Everything you need to ship your first product yourself.
We have no partnerships with the providers mentioned here. We recommend what we use ourselves.
Setup
Seven things you set up once. Details, commands and alternatives live on the setup page.
An Anthropic account with an active subscription is the baseline. One plan is enough — Pro to start, Max once you need longer sessions or more token budget. Without an active subscription there's no Cowork and no Claude Code.
Cowork lives as a third tab inside the Claude Desktop App — no extra install needed. There you describe in conversation what you want to build, until the concept is clear.
Two setup paths: terminal (maximum flexibility) or VS Code (code, terminal and Claude in one window) — the output is the same. The command below installs the native client: no Node.js needed, updates run automatically in the background. Security tip: ideally work on a separate computer with no personal data on it. Claude Code gets full file access, so a clean separation matters.
Backup after every sprint. API keys, internal notes and early architecture sketches stay locked down. Vercel and Netlify deploy directly from GitHub — so the workflow pays off twice.
Every project folder gets a file called CLAUDE.md. It's the rulebook for your sessions. How you work, which stack you use, which mandatory checks (GDPR, performance, accessibility) always run, what's off-limits. Claude Code reads it automatically on every start. Without a CLAUDE.md the AI starts from zero each time.
B · Slash commands and modes
Slash commands clean up the context and steer Claude Code. Three modes decide how independently Claude works.
/clearClear the context between different tasks — saves tokens.
/compactSummarise the history when the session gets too long.
/debugSystematic debugging. Reproduce, hypothesise, test, propose a fix.
/planActivate plan mode. Claude analyses the task and writes a plan before coding.
/dreamBrainstorm and ideation mode. Claude thinks out loud with you without coding directly.
/initSet up a project, create CLAUDE.md, set defaults.
/rewindRoll back to an earlier state — restore a checkpoint.
/pluginInstall or manage a plugin, add an MCP server.
/loopRepeat a request or slash command on a fixed interval (e.g. /loop 5m /babysit). Without an interval, Claude paces itself.
/usageCheck current token usage.
/effortHow much reasoning effort Claude spends on an answer, from low to max. More for tricky tasks, less for routine ones.
/modelSwitch models (Opus, Sonnet, Haiku). opusplan lets Opus plan and Sonnet execute: quality on the plan, cheaper on the code.
/goalSet a goal Claude keeps working toward until it is met. /goal clear removes it.
/resumePick up an earlier session with full context. Handy when you continue exactly where you left off after a break.
/quitEnd the session and restart. You need this so freshly installed skills and plugins get loaded.
You type these without a slash, directly in your request.
ultracodeNot a classic slash command: you use the word "ultracode" in your request. Claude Code then orchestrates several agents in parallel and plans or builds larger tasks in one go.
Claude researches and proposes a plan before code gets written. You read it, say „looks good“, then Claude starts.
When to use it: For anything that isn't trivial. Standard for every new feature.
Claude carries out a confirmed task directly without asking again. Step by step, with visibility into tool calls.
When to use it: When the plan is set and you just want the result.
Claude works through autonomously and doesn't ask in between. Riskier but faster.
When to use it: For clear, small tasks or when you need sprint power.
Before you start
Two ways to work with the same tool. One gets you to the finish line on small stuff. On real projects, you go in circles. The other turns Claude Code into a system that gets better with every task.
PROMPT AND HOPE
You describe roughly what you want. Claude tries something, you tweak it. Again and again. That works for small things. On real projects you go in circles: every time you start from zero, nothing gets saved, nothing gets better. That's exactly what Boris Cherny, the head of Claude Code, warns about.
TRY · HOPE · TWEAK · START OVER
SYSTEMS OVER CHANCE
The way Boris Cherny himself works: fixed rules (CLAUDE.md), specialists (subagents), reusable commands, skills, and connections (MCP servers). "Let's see what happens" turns into a setup that gets better with every task.
RULES · SUBAGENTS · COMMANDS · SKILLS · MCP
The three phases
Whether you build a web app, an iOS app or a small automation, the path is the same. You plan, you build, you test. We walk through it on our own tool, the KI-Bundestrainer, and you take the same three steps for your idea.
Tool · Claude Cowork
Tool · Claude Code
Tool · Browser, simulator, logs
Main tool: Claude Cowork.
You describe what your app should do and tell Claude to keep asking until the concept is solid. At the end Claude generates a markdown file with the finished concept. That's your briefing for the coding phase.
Default prompt for Claude Cowork (adapt and copy):
I want to build a [web app / iOS app / Android app].
It should have the following features:
[describe features here]
The target audience is:
[describe the target audience here]
Keep asking me questions about features, edge cases, and target audience until you fully understand the concept.
Also clarify the data and architecture side with me:
- Which data does the app store and process?
- Which of it is critical (sensitive, confidential, regulated — e.g. health, finance, personal notes)?
- Which data must WE own as the operator (server, database, backups)?
- Which data should belong exclusively to the user (local on device only, end-to-end encrypted, never on our servers)?
- Which software architecture fits (pure frontend app with local storage, backend with auth + database, E2E-encrypted sync …)?
Then build a markdown file with the finished concept that I can share with Claude Code in the next step.Second route: the Ultracode commandNew in Opus 4.8
Instead of planning step by step, since Opus 4.8 you can use the word "ultracode" in your request (briefly called "workflow" at launch). Claude Code then writes an orchestration script itself, starts several agents in parallel and plans out a whole process or a complete app. If you prefer to think in dialogue, the brainstorm skill or the ECC plugin with its planning agents will help.
You don't need to code yourself today. A basic grasp of software architecture still pays off. The most interesting question is almost always: what actually happens to the data? Which ends up on your servers, which only on the user's device, which must never leave the browser?
Once you build an app that handles sensitive data (health, finance, journal, customer data), you make that architecture call consciously, before a single line of code gets written. That's exactly what the data block in the prompt above is for.
Your tool: Claude Code. Details on setup, slash commands and plan mode are in section B.
Workflow:
Default prompt for Claude Code (copy and paste):
Read the markdown file I placed in the project folder.
Based on this concept, build the application. If you have questions, please ask them before you start.
Please program the app in several sprints — we always do only one clearly scoped part at a time. At the end of each sprint, tell me what you built and what is next.
Important:
- Plan mode before every larger change. First the plan, then my confirmation, then the code.
- Actively raise the mandatory checks: GDPR, performance, multilingual support, accessibility.
- After each milestone, propose a commit command (private repo on GitHub).Up to here it's easy. You talk to the AI, say what it should do, and the AI handles the rest. Test and optimisation are the interesting part. Real problem-solving lives here. Does the UX hold up when a user does something unexpected? Does your tool give the answers it should, or is the model hallucinating? How much do the tokens cost per call?
The details on token economics, hallucinations and timeouts are in section G. Here are the typical questions that come up in this phase:
Workflow/planbrainstorm/clear/compact/rewind/debugcode-reviewChrome-DevTools-MCPA few commands are enough to start. You learn the rest when you need them.
Skills & plugins
Skills are single instructions, plugins bundle several into one workflow. The full list including the skill-vs-plugin comparison lives on the setup page.
memory
Anthropic skill for persistent memory across sessions. Stores decisions, lessons learned and project context.
skill-creator
Helps you build your own skills, improve existing ones and test them with evals.
ui-ux-pro-max
Anthropic skill for UI/UX design — generates components, watches design-system consistency, typography, spacing and accessibility.
MCPs
MCPs give Claude access to your world — files, GitHub, docs. The full curated list with setup commands and security notes lives on the setup page.
Filesystem (official)
Controlled read/write access to specific local folders. The foundation for „Claude builds in my project“.
GitHub (official)
Read repos, create issues and PRs, write reviews, trigger actions. Claude becomes a team member.
Context7 (Upstash)
Gives Claude version-specific, current docs for libraries (React, Next.js, Tailwind …) to counter LLM hallucinations with outdated APIs.
Vibe coding tools
Because it burns token money you don't need to spend. Vibe-coding builders get you to 70 percent — the last 30 percent (auth flows, custom logic, security) you pay in credit loops that escalate fast. With Claude Code it's cheaper, and there are still good products out there.
The tool cards — Lovable, Bolt, v0, Rork, Replit, Cursor, Figma Make — live on the tools page, with pricing, strengths and weak spots. That's where they belong.
Go to the tool cardsD · Connection tools
Backend, AI connection, hosting, automation — depending on the product type. One recommendation per area plus a note on when you really need it.
Supabase
When: As soon as your app stores data: logins, profiles, posts, caches.
Postgres + auth + storage + edge functions in one. EU region in Frankfurt. The free tier covers your first projects.
Anthropic API · OpenAI · Google Gemini
When: When your product calls AI (not just the coding AI).
Call it through a backend proxy, never directly from the frontend. API keys as environment variables, not in code.
Vercel
When: When your web app should go online.
Connect a GitHub repo, push, automatic deploy. Your own domain in 5 minutes. Edge functions included.
n8n · Make · Zapier
When: For workflows between tools — without your own app.
n8n self-hosted for cheap, predictable costs. Make for visual mid-market workflows. Zapier for maximum simplicity.
Security · Before your product goes live
The same three mistakes show up in vibe-coding projects again and again. All three are avoidable if you walk through them once before launch.
Keys belong on the server as environment variables. Whatever lands in your frontend bundle or git history is public, and automated scanners look for exactly that.
Every public function that triggers AI or API calls needs a limit per user and time window. Without one, a single script can call your app endlessly, and you pay for every single request.
In Supabase that means: enable RLS on every table, with policies that only allow each user their own rows. Without RLS, anyone with your public key can read other people's data.
And before all that, the basic question: Which user data do you actually need to store on your server? Anything that can stay on the user's device stays out of your database and makes data protection much simpler.
The check for it
Claude Code ships with its own security review. Run it once before every launch, it finds exactly these classics.
/security-reviewToken economics & scaling
Cheap to build is one thing. Running the tool long-term without the bill crushing you is another. Tokens are the operating cost of your AI app. If you don't control models, caching and pre-computation, the first viral day turns into a money pit.
Projection: 100,000 users × 2 generations × 16,000 tokens on a premium reasoning model. Result: around 156,000 USD per day. After the four levers below we were at around 65 USD per day. A reduction of −99.96 percent.
The four levers at a glance
From 156,000 USD/day to around 65 USD/day. The four levers stacked on top of each other:
| Lever | What happens | Effect |
|---|---|---|
| 1 · Model choice | Switch from Opus 4 to GPT-4o-mini | −95% model cost |
| 2 · Pre-computation | Research data once, store it in the DB | −98% web search |
| 3 · Caching | Repeats from cache instead of recomputing | ≈ −65% requests |
| 4 · Max-tokens cap | Hard limit on output length | −30% latency |
First · What you can do while building
Token optimisation doesn't start with model pricing. It starts with how you work with Claude Code. Three levers that take effect immediately, before you touch a single line of model logic:
Setup · Three cost levers inside Claude Code itself
Your setup has its own dials, before a single line of product code runs. Three things we use ourselves:
Sonnet 5 instead of Opus
For most coding tasks Sonnet 5 is close to Opus 4.8 at a fraction of the cost: 2 USD input and 10 USD output per million tokens (intro pricing until August 31, 2026, then 3 and 15; Opus is at 5 and 25). Plus a 1M context window. On Free and Pro plans Sonnet 5 is now the default model.
# switch inside a running session:
/model
# or right at startup:
claude --model sonnet
# permanently, in ~/.claude/settings.json:
{ "model": "claude-sonnet-5" }Headroom as a compression proxy
A local proxy between Claude Code and the model. It compresses tool outputs, logs and file reads before they hit your context, and stays reversible: the model can fetch the original anytime. Benchmarks show 60 to 95 percent fewer tokens on JSON- and tool-heavy workflows, more like 15 to 20 on pure coding sessions. Open source (Apache 2.0, around 58,000 GitHub stars), everything runs locally on your machine.
# install (Python; Node works too):
pip install "headroom-ai[all]"
# start Claude Code compressed:
headroom wrap claude
# optional: learns from failed sessions,
# writes fixes to CLAUDE.local.md:
headroom learnponytail for shorter code
The plugin keeps Claude's code compact and focused. Fewer generated lines means fewer output tokens. For shortening replies and your CLAUDE.md we also use the caveman skill from the skills section.
/plugin marketplace add DietrichGebert/ponytail
/plugin install ponytail@ponytail
# control afterwards:
/ponytail lite | full | ultra | offPremium reasoning models (Claude Opus, GPT-4) are too much for most use cases when you make structured decisions from a predefined pool. Switch to stats-optimised classes (GPT-4o-mini, Claude Haiku 4.5) and you pay sub-cent per call instead of multiple cents.
Model table (pricing bars relative to Opus 4 = 100%):
| Model | Input · 1M tok | Output · 1M tok | Output relative | Notes |
|---|---|---|---|---|
| Claude Opus 4 | 15 USD | 75 USD | 100 % | Top quality, often too expensive for structured picks |
| GPT-4 (Classic) | 30 USD | 60 USD | 80 % | Overkill when you only pick from a pool |
| Claude Haiku 4.5Our pick | 1 USD | 5 USD | 7 % | Our pick for texts with tone — best voice quality at sub-cent |
| OpenAI GPT-4o-miniOur pick | 0,15 USD | 0,60 USD | 0,8 % | Our pick for structured tasks — JSON, classification, picks |
| DeepSeek V3 | 0,27 USD | 1,10 USD | 2 % | German generation: weak, especially in style/satire registers |
| Qwen 2.5 72B | 0,35 USD | 0,40 USD | 0,6 % | German generation: weak in non-neutral registers |
| Gemini 2.0 Flash | 0,10 USD | 0,40 USD | 0,5 % | Very cheap but schema fails on strict JSON requirements |
List prices rounded. Chinese models are nominally cheap but unusable for German generation in certain registers (e.g. satire). The word choice slips into generic fast.
Practice tip: Use models in parallel. On the KI-Bundestrainer we use Anthropic for texts with style (satire, opinion pieces) and OpenAI for structured tasks (squad selection). That saves money and gives each use case the right tool.
Data that rarely changes you research once and store in a database. When generating, the AI only reads from there instead of searching again on every call. Live data you pull in larger intervals (e.g. once per day), not per user request.
Example: On the KI-Bundestrainer we researched the 108 candidates once. Current form, injuries and opponent analysis we fetch once per World Cup match.
Effect · −98 percent web search cost.
When two users ask the same thing, the AI shouldn't compute twice. Save the inputs plus the result on every request. On a repeat you serve the cached result instead of running the AI again.
Effect · Around 65 percent of requests drop entirely, more depending on the use case.
Bonus: prompt caching at the provider
Prompt caching at the provider. Both Anthropic and OpenAI cache recurring prompt parts (system prompts, fixed instructions) automatically. Cache hits cost roughly a tenth of the normal input price at Anthropic — up to 90 percent savings. Build your prompt so the stable part comes first and the variable user input comes last.
Models often allow „up to 16,000 output tokens“ and use it as a free pass to think out loud, even when the output would be much shorter. Set a hard cap (e.g. 7,000). The model reads that as a budget signal and shortens automatically. No quality loss because the real output volume usually sits below.
Effect · −30 percent latency, fewer timeouts as a side effect.
Advanced
Four concepts you don't need on day one, but they sharpen your setup once you build regularly.
Output styles give Claude a different persona — e.g. "learning" (explains every step) or "explanatory" (more inline code comments). You install them as plugins and switch via /output-style. Handy when you want to flip between "just ship it" and "I want to learn while I build".
Hooks are small automations that fire on specific events — before or after a tool call, before a commit, when a file is edited. You use them to enforce behaviour you'd otherwise trigger by hand („run tests before every commit“, „show a security warning when editing an auth file“).
Permissions define what Claude can do without asking and what it can't. Three levels: allow, ask, deny. Important as soon as the AI runs on its own (auto mode, subagents, hooks). Defaults are safe, but you can tighten them per project — e.g. filesystem writes only in specific folders, no shell commands without confirmation.
The Agent SDK is how you put Claude directly into your finished product. The console tool becomes an agent that lives in your app. You build your own tools, define system prompts, give the agent access to your database — and end users talk to Claude through your interface instead of the console.
Weekly log
Our setup is never finished. Every week brings new skills, rules and automations. We document every change here so you can adopt it for your own setup.
The global CLAUDE.md is the rulebook behind all our builds. We share it as a file, cleaned of personal paths and project internals. Every change to it shows up in the log below and in the changelog article.
Our Instagram card in the dashboard only showed a snapshot so far: followers, reach, the last eight posts. The new skill builds a growing post history from that, calculates the engagement rate per post, and once there are enough data points, spots rough patterns in caption hooks. First real run against our own account: question hooks perform noticeably better on average than statement hooks, though still on a small sample. Result lands directly as a new block in the existing dashboard card.
Built two small skills for the new finance tab in the dashboard, each running on demand per ticker: position-earnings-review summarizes the latest quarterly earnings release (beat/miss, guidance change, three to five key points), position-news-review scores the last one to two weeks of news by sentiment and impact. Both write their result as JSON, and the dashboard renders a card per position from it. Pure WebSearch/WebFetch, no external data provider.
Our whole Claude Code setup (CLAUDE.md, skills, agents, commands) now lives in its own git repo instead of directly inside ~/.claude. A setup.sh script symlinks the files back. On a new machine, a clone plus one script call brings the whole setup back. Before, ~/.claude itself was the repo, which coupled our configuration to Claude Code's own directory structure more tightly than we liked.
Before we adopt anyone else's Claude Code setup or tool repo, a read-only audit now runs first: stars, structure, number of skills/agents/commands, recent activity. Triggered via /research-repo <url>, the agent closes with a clear call: adopt, skip, or worth a closer look. Stops a well-marketed repo from sliding into our own setup unchecked.
Audited via our own repo-research-agent: cathrynlavery/diagram-design (26,000 stars) builds editorial diagrams as standalone HTML+SVG with Playwright export, deliberately skipping Mermaid. Same rendering stack as our carousel skills, carousel-inzpyre and tste-carousel, just for diagrams instead of social posts. We are not installing the skill, the diagram types do not fit our content. Three patterns we are taking for the next carousel iteration: the Playwright export recipe with a networkidle and fonts-ready wait as a robustness check against our own render.js, semantic design tokens instead of raw hex values, and a brand profile that derives itself automatically from a URL.
A new skill for frontend work with fixed phases: clarify style questions first, then an audit against eight known AI-slop patterns, then a DESIGN.md as the binding reference, then rebuild screen by screen with a screenshot comparison after every step. At the end, ten acceptance questions that all have to come back no before anything counts as done.
A skill for the final check before submitting to the App Store: several agents check review compliance, GDPR, backend security, StoreKit/monetization, and localization in parallel, plus a Codex tandem for auth/payment/security. Mechanical issues get fixed directly, everything else lands as a go/no-go list with the items that need a human call. Built from the first real run on one of our apps, not designed on paper.
Second skill in the newsletter pipeline: once a newsletter is sent, this skill automatically turns it into a bilingual blog article for the website, following the pattern of an earlier newsletter that was already converted this way once. One format, two channels, without writing the text twice.
A new section collects patterns from Anthropic's own prompt library: state the outcome instead of prescribing steps, ship verification along with the task instead of just "write tests", point at a reference pattern instead of dictating implementation, use a measurable goal instead of vague quality. If a task comes in unclear or too granular, it gets rephrased against these patterns before starting and shown back for a quick confirmation.
A new skill assembles the skeleton of the next newsletter issue from what really happened since the last send: git commits, memory entries, the news digest from our daily AI briefing. What comes out is a draft, not a finished mailing. Where data is missing, the skill drops a placeholder instead of inventing something. The pattern fits any recurring format you would otherwise start from a blank document.
Two of our scheduled runs kept failing at login in the morning. The cause was power management: the Mac fires the jobs even out of Power Nap, and in that half-awake state networking is not up yet, so the token refresh went nowhere. A `caffeinate -u` before the start forces a real wake, and a `caffeinate -i` keeps the machine awake for the length of the run. If your automation only fails at night, look there first and not at the script.
Our content automations pick topics and images on rotation. Within one week we shipped two duplicates, both for the same reason: the pick came from pure arithmetic (day number modulo X) or from folder order, and nothing recorded what had already gone out. When two modulo values share a factor, that even produces a fixed pattern which repeats the exact same combination every eight days. Now every pick writes down what it used, and the least recently used candidate wins.
A daily launchd job once fired while the Mac was still asleep or locked: Keychain access for the Claude session was briefly unavailable, the run failed with an auth error, but the daily dedup gate still stamped the day as done. Fix: a short claude -p smoke test with a timeout before the real run. If it fails, only the lock gets released, last-run stays unstamped, so a later trigger can still succeed the same day.
New skill builds Instagram reels (9:16, 20-30 seconds) for a culinary app: script, AI-generated b-roll, voiceover, HTML/CSS/Playwright text overlays, ffmpeg final assembly. Builds on tste-carousel's architecture (cadence proposal, manual approval, no auto-post), but with real video and TTS costs per run instead of ~$0.04 per image. That's why the automatic cadence trigger stays off until there's an explicit cost go-ahead.
New skill pre-fills the App Store Connect form fields (app information, privacy label, pricing, IAP, store copy) with facts it reads straight from the code, like product IDs from the .storekit file or the data actually collected per the privacy manifest. Complements a technical pre-submission audit another skill handles: where the repo has no evidence, it flags the field as open instead of guessing.
New skill for Next.js/Supabase admin panels: auth+nav, self-built tracking, newsletter, a private media library, and bulk actions as parameterized modules. It only builds what an app actually needs, none of the 5 modules is mandatory.
New skill scans AI news every day, turns it into an internal one-pager, a website update, and an Instagram story, renders the story as a PNG, and posts it without manual approval. A watchdog timeout stops one hung run from blocking the whole chain.
New skill builds Instagram and LinkedIn carousels for a culinary app: slide copy, HTML templates, Playwright rendering, delivered as ready-to-post images. 3 design directions and 4 content formats are locked in upfront, no redesign for every post.
2 automation skills wrote straight into Obsidian's data.json and lost changes to the plugin's own saveSettings() call, which keeps its own in-memory copy and overwrites the file on any interaction. Fix: automations now write to their own outbox files, which the plugin drains race-safely, now shared as one module across skills.
Automated skills now write ok or error to a shared status file at the end of every run, which a dashboard can read. Before, a dead background run stayed invisible: an empty lock got cleared silently, with no error showing up anywhere.
A background process triggered by launchd failed on a file operation even though the Terminal app had Full Disk Access. macOS TCC binds the permission to the binary that actually runs, here the claude process itself, not the app that launched it. Fix: grant Full Disk Access directly to the claude binary.
A new skill builds Instagram carousels (1080x1350, static) from website content or notes, through a shared HTML and Playwright render pipeline in our own brand design. A new cadence mode now suggests a carousel automatically every two days: a gate script checks timing and open topics, a launchd hook starts the run headless in the background.
Over 20 specialized SEO subagents in one plugin: technical SEO, content audits, schema markup, backlinks, local SEO, and GEO/AI search optimization for Google AI Overviews, ChatGPT, and Perplexity. Each area runs as its own agent with its own tool access, instead of learning a new tool for every subtask.
New rule in the remotion-best-practices skill: crossfade and morph transitions between scenes need a fixed-size stage container with absolute positioning instead of normal text flow. Negative margins used to compensate for flow layout break the render timing otherwise. A lesson from building our own carousel render pipeline.
A new skill screens the Claude Code and AI ecosystem daily: Anthropic releases, GitHub repos, skills, plugins, MCPs, community discussions, and OpenAI/Codex news. A stop hook with a 20-hour gate and a lock mechanism triggers the run automatically, deduplicates against what it already saw, and writes a briefing with up to 3 setup recommendations.
A dedicated skill collects all setup changes once a week (CLAUDE.md, skills, plugins, MCPs), writes them to this page and the changelog article, and opens a review PR. Triggered by a stop hook with a 7-day gate, modeled on our memory consolidation.
New rule in our CLAUDE.md: anything above 3 files or 30 minutes of work gets an additional review from OpenAI Codex as a second model. Two models with different strengths find more bugs than one. Findings get evaluated, never adopted blindly.
We went through all installed plugins and disabled two we were not actively using. Every active plugin attaches its descriptions to every session and eats context window. Pruning regularly pays off.
Your build challenge
You only understand AI by using it yourself. A small tool, a weekend experiment, an internal script. Doesn't matter. You don't need to become a techie. You just need to have started once.
Pick a form: web app, iOS app, small automation or workflow. Walk through the three phases from section A — planning with Claude Cowork, coding with Claude Code, testing in the browser or simulator. Block off a weekend. You'll be surprised how far you get.
Recommendations for this topic
Creators and newsletters that fit this cluster thematically. Outside voices, curated by us.
Out in front on building with Claude Code. Deep practical insights and his own academy (SKAILE) for everyone who's serious about building software with AI.
Founder case studies by Pat Walls: how real founders launched and marketed their products, with concrete numbers. Great for learning growth tactics from real examples.
On to the next station
Build automation with AI
Plan workflows, then ship them with Claude Code. n8n + Hetzner — cheap, fast, yours.