feat: toolbox, showcase, AI-enhanced generator, 4 new articles

Closes the competitive gap vs vibeworkflow.app, KhazP template, and
vibecoding.app. Highlights:

- /toolbox hub: generators, scanners, templates (replaces /generator in nav)
- /built-with showcase: 6 real apps shipped using the workflow
- /api/generate: Claude Haiku 4.5 endpoint with prompt caching + kv rate-limit
  (5/hr/IP). "Enhance with AI" button on /generator. Graceful fallback to
  template when ANTHROPIC_API_KEY is missing.
- MEMORY.md template (matches KhazP's session-continuity pattern)
- 4 new articles:
  - which-llm-for-which-step (model strategy matrix, SEO play)
  - agents-vs-claude-vs-cursorrules (Linux Foundation standard explainer)
  - claude-code-vs-codex-cli (terminal-agent comparison)
  - cursor-vs-windsurf (AI-IDE comparison)
- Workflow improvements:
  - Time estimates per step (45 min, 60-90 min, etc.)
  - Step 01 promoted to "Deep Research" with 2 extra tasks (user
    interviews + quantify wedge)
  - workflow-steps.ts synced to 10 steps (was stale at 9)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: dotsystemsdevs

content/articles/agents-vs-claude-vs-cursorrules.md

@@ -0,0 +1,149 @@
+---
+title: "AGENTS.md vs CLAUDE.md vs .cursorrules: Which One Should You Use?"
+description: "Three context-file formats, one job. Why AGENTS.md is winning, what each tool actually reads, and the safest setup that works across Claude Code, Cursor, Codex, and Windsurf."
+date: "2026-05-20"
+image: "https://images.unsplash.com/photo-1456513080510-7bf3a84b82f8?w=1200&q=80"
+imageAlt: "Stack of paper documents"
+author: "vibeprompt"
+category: method
+---
+
+If you've used more than one AI coding tool in the past year, you've hit this: Claude Code wants `CLAUDE.md`. Cursor reads `.cursorrules` (or the newer `.cursor/rules`). Codex CLI looks for `AGENTS.md`. Aider has its own conventions. Now you've got four files in your repo, all saying mostly the same thing, all slightly out of sync.
+
+This article explains what each file actually does, why **AGENTS.md is winning**, and the exact setup that lets one file drive every tool — without maintaining four copies.
+
+## The three formats, side by side
+
+| File | Tool that wrote it | Adopted by |
+|---|---|---|
+| `CLAUDE.md` | Anthropic (Claude Code) | Claude Code only |
+| `.cursorrules` (legacy) / `.cursor/rules/` (current) | Cursor | Cursor, Windsurf (partial) |
+| `AGENTS.md` | OpenAI (Codex), then Linux Foundation | Codex CLI, OpenCode, Aider, Cline, Windsurf, Roo, Cursor (reads it) |
+
+The pattern is unambiguous: `AGENTS.md` has the broadest tool support and is now stewarded by the [Linux Foundation as an open standard](https://agents.md). Every major agent either reads it directly or has a config flag to point at it.
+
+## What each file actually does
+
+All three serve the same purpose: **give an AI coding agent the project-specific context it can't infer from the code alone.** Conventions, stack versions, what-not-to-do rules, build commands.
+
+The differences are mostly cosmetic:
+
+- **`CLAUDE.md`** is plain markdown. Claude Code loads it at session start and treats it as authoritative.
+- **`AGENTS.md`** is the same idea, formalized. The Linux Foundation spec defines section conventions (Project, Stack, Conventions, etc.) so tools can predict structure.
+- **`.cursorrules`** was Cursor's original format — single-file rules with optional path globs. The newer `.cursor/rules/` directory splits rules into files with frontmatter for scoping (`description`, `globs`, `alwaysApply`).
+
+There's no functional difference for 95% of users. They all end up in the model's system prompt.
+
+## Why AGENTS.md is winning
+
+Three reasons:
+
+1. **Vendor-neutral.** `CLAUDE.md` ties you to Anthropic. `.cursorrules` ties you to Cursor. `AGENTS.md` doesn't tie you to anything.
+2. **Standardized structure.** The spec means tools can extract specific sections (e.g. "find the build command") deterministically.
+3. **Tool support snowballed in late 2025.** When Codex CLI shipped AGENTS.md support, OpenCode, Cline, Roo, and Aider followed within weeks. Cursor and Claude Code both now read it.
+
+If you're starting a project today, write `AGENTS.md` and stop there.
+
+## The "one file, all tools" setup
+
+If you already have `CLAUDE.md` (or `.cursorrules`), don't migrate everything to AGENTS.md — that's a recipe for drift. Use one of these three patterns:
+
+### Pattern 1: Symlink
+
+The cleanest option. One file, every tool reads it:
+
+```bash
+# AGENTS.md is the source of truth
+ln -sf AGENTS.md CLAUDE.md
+ln -sf AGENTS.md .cursorrules
+```
+
+Pros: Zero drift. Edit once, all tools see the change.
+Cons: Symlinks don't always survive zip downloads / Windows / some CI checkouts.
+
+### Pattern 2: Pointer file
+
+If symlinks are off the table, make one canonical file and have the others point to it:
+
+```markdown
+# CLAUDE.md
+READ AGENTS.md FIRST. That is the source of truth.
+```
+
+Tools that load `CLAUDE.md` will hit the pointer and read `AGENTS.md` next. Works because most agents follow `@file` references and `READ X` instructions.
+
+### Pattern 3: @file include
+
+In a tool that supports it (Claude Code, Cursor, Codex):
+
+```markdown
+# CLAUDE.md
+@AGENTS.md
+```
+
+Claude Code expands `@AGENTS.md` to the file contents. Same effect as a symlink without filesystem trickery.
+
+## What to put in your AGENTS.md
+
+The Linux Foundation spec recommends these sections. Steal this skeleton:
+
+```markdown
+# AGENTS.md
+
+## Project
+**Name:** [Project]
+**One-line:** [What it does]
+**Stack:** [e.g. Next.js 16, TypeScript, Tailwind v4, Vercel]
+
+## Folder structure
+[Tree of relevant dirs]
+
+## Conventions
+- File names: kebab-case
+- No file exceeds 500 lines
+- Server-only code in lib/, imports "server-only"
+
+## Hard rules
+1. Never overwrite without asking
+2. No new dependencies without explicit request
+3. Every feature needs 3 tests
+4. No-touch list: .env, package-lock.json, next.config.ts
+
+## Build & verify
+- npm run dev
+- npm run typecheck
+- npm run lint
+
+## Session kickoff
+At session start: "Read AGENTS.md, docs/PRD.md, and memory-bank/ before doing anything."
+```
+
+A full [AGENTS.md template](/templates/AGENTS.md) is on this site under templates.
+
+## Mistakes to avoid
+
+**Don't include the PRD in AGENTS.md.** The PRD changes constantly. AGENTS.md is *rules*, not *scope*. Keep them in separate files (`docs/PRD.md`) and reference the PRD from AGENTS.md.
+
+**Don't write 200 lines.** Models drop attention past the first ~80 lines of a system prompt. Keep AGENTS.md under 100 lines. If you have more to say, link out to longer docs.
+
+**Don't add things "just in case."** Every rule you write is a constraint the model has to track. Be specific about what matters, vague about what doesn't.
+
+**Don't forget to update it.** Stale rules are worse than no rules — they tell the model to do things you no longer want. Touch AGENTS.md in the same commit as breaking convention changes.
+
+## Tooling-specific quirks
+
+A few footguns worth knowing:
+
+- **Cursor** still reads `.cursorrules` for backward compatibility, but the newer `.cursor/rules/` directory is preferred. If both exist, `.cursor/rules/` wins.
+- **Claude Code** has a hierarchy: `~/.claude/CLAUDE.md` (global) → `./CLAUDE.md` (project). Both get loaded. Use the global one for personal preferences, the project one for project-specific.
+- **Codex CLI** supports monorepo `AGENTS.md` files — drop one in each package, Codex picks the closest one to your working directory.
+- **Aider** reads `CONVENTIONS.md` by default. Symlink that to `AGENTS.md` too if you use Aider.
+
+## TL;DR
+
+- Write **AGENTS.md** as your source of truth.
+- Symlink or pointer the others (`CLAUDE.md`, `.cursorrules`) to AGENTS.md.
+- Keep it under 100 lines, rules-only — not scope.
+- Update it in the same commit as breaking convention changes.
+
+This stops the four-files-out-of-sync problem cold. Every tool reads the same content, you edit one place.

content/articles/claude-code-vs-codex-cli.md

@@ -0,0 +1,102 @@
+---
+title: "Claude Code vs Codex CLI: Which Terminal Agent to Pick in 2026"
+description: "Anthropic's Claude Code and OpenAI's Codex CLI both live in your terminal, both edit your codebase, both cost money. Here's where they diverge — and which one to use for what."
+date: "2026-05-20"
+image: "https://images.unsplash.com/photo-1629654297299-c8506221ca97?w=1200&q=80"
+imageAlt: "Terminal window showing code"
+author: "vibeprompt"
+category: method
+---
+
+The two terminal agents that matter in 2026 are **Claude Code** (Anthropic) and **Codex CLI** (OpenAI). Both install with one command, both edit your repo, both run for hours unattended if you let them. They look identical from a distance.
+
+Up close, they have meaningfully different personalities, pricing models, and strengths. This article picks them apart so you can decide which one fits your workflow — or whether you should run both.
+
+## The bare facts
+
+| | Claude Code | Codex CLI |
+|---|---|---|
+| **Vendor** | Anthropic | OpenAI |
+| **Default model** | Sonnet 4.6 | GPT-5 medium |
+| **Install** | `npm i -g @anthropic-ai/claude-code` | `npm i -g @openai/codex` |
+| **Pricing** | Subscription ($20+/mo) or API | ChatGPT Pro/Plus or API |
+| **Permission modes** | Default / Auto-accept / `--dangerously-skip-permissions` | Suggest / Auto-edit / Full-auto |
+| **Memory file** | `CLAUDE.md` + `AGENTS.md` | `AGENTS.md` |
+| **MCP support** | Yes (server + client) | Yes (client only at time of writing) |
+| **Plan mode** | Yes (`Shift+Tab`) | Yes (`/plan`) |
+| **Open source** | No (closed CLI) | [Yes, Apache 2.0](https://github.com/openai/codex) |
+
+## Where Claude Code wins
+
+**Conversational personality.** Claude Code is noticeably more "pair programmer" — it asks clarifying questions, admits uncertainty, and pushes back when your request is ambiguous. Many developers describe it as collaborative.
+
+**Long, complex tasks.** Sonnet 4.6 and Opus 4.7 hold context better than GPT-5 on multi-hour autonomous runs. If you're letting an agent work for 30+ minutes without checking in, Claude Code is more likely to still be on task when you come back.
+
+**Tool ecosystem.** Claude Code's MCP support is more mature. You'll find more pre-built MCP servers (databases, design tools, observability) than for Codex.
+
+**The 1M+ token context window.** For projects with sprawling codebases, Claude's larger context lets you load more files into a session without hitting limits.
+
+**Skill system.** Claude Code's skill system (`/skill`, `.claude/skills/`) lets you bundle reusable workflows and patterns. Codex doesn't have a direct equivalent yet.
+
+## Where Codex CLI wins
+
+**Personality if you want robotic.** Codex is dry, direct, and doesn't agree with you for the sake of it. If you've been frustrated by "You are absolutely right!" patterns in Claude Code, Codex feels refreshingly blunt. It will tell you your idea is wrong.
+
+**Open source.** The CLI itself is Apache 2.0. You can read the source, fork it, audit the agent loop. For security-sensitive teams, this matters.
+
+**Visual context.** Codex's drag-and-drop screenshot support is excellent — you can paste UI mockups, design files, or architecture diagrams directly into the chat. Claude Code supports this too but Codex's flow is smoother.
+
+**Sandbox modes.** Codex's three permission modes (`--suggest`, `--auto-edit`, `--full-auto`) are more granular than Claude Code's binary "permission prompt" vs "skip permissions." If you want auto-file-edits but still want to approve shell commands, Codex handles that natively.
+
+**Tighter coupling with ChatGPT.** If you live in ChatGPT for chat + Codex for coding, the experience is unified. You can start a conversation in ChatGPT, hand it to Codex, see the same context.
+
+## Where they're basically the same
+
+- **Quality on typical coding tasks.** For "write me a function" / "fix this bug" / "refactor this module," both produce comparable code. Empirical benchmarks bounce around but the gap is rarely >5-10%.
+- **Speed.** Both are gated by inference latency more than CLI overhead. Sonnet 4.6 and GPT-5 medium are both in the 2-4 second range per tool call.
+- **Git integration.** Both write commits, both can be told to push, both handle conflicts (poorly — see "weaknesses" below).
+- **Reading large repos.** Both will read 20+ files in a single task without complaining.
+
+## Where both still suck
+
+Fair warning — both agents share the same weak spots:
+
+- **Conflict resolution.** Neither handles a real git merge conflict well. Resolve them yourself.
+- **External API debugging.** "The endpoint is returning 500" — both will hallucinate fixes if they can't see the actual response. Always paste the real error.
+- **Visual UI work.** Both can iterate on layouts with screenshots, but neither beats opening DevTools and tweaking manually.
+- **Long-running migrations.** Both lose the plot on 50+ file refactors. Break them up.
+
+## Which one to pick
+
+### Pick Claude Code if:
+- You want a collaborative, conversational agent
+- You're running complex multi-hour autonomous tasks
+- You use a lot of MCP servers
+- You're already on Anthropic's API or Claude Pro
+
+### Pick Codex CLI if:
+- You want an agent that pushes back instead of agreeing
+- You need the CLI to be open-source (security review, audit, fork)
+- You live in ChatGPT for chat
+- You want granular permission modes per-operation
+
+### Run both if:
+- You're shipping serious indie work and want diversity in failure modes
+- One agent gets stuck, switch to the other (they fail on different things)
+- You want to use the [one-writes-another-reviews pattern](/articles/vibe-coding-mistakes) — code in Claude, review in Codex (or vice versa)
+
+The "run both" path is more common than you'd think. Many indie devs keep two terminals open and ship faster by having a second opinion always available.
+
+## Cost reality (May 2026)
+
+Subscription path: **$20-30/mo for each.** Claude Pro + Codex Pro = $40-50/mo total, which is much cheaper than the API path for typical individual usage.
+
+API path: **wildly variable.** A heavy day on Opus 4.7 can hit $50+; the same day on Sonnet is closer to $5-10. Codex with GPT-5 is in the same ballpark. See the [model strategy matrix article](/articles/which-llm-for-which-step) for which model to use when.
+
+If you're on a budget, start with the subscription tier of whichever vendor feels more aligned. Switch to API if you outgrow the subscription quota.
+
+## TL;DR
+
+Both terminal agents are good. **Claude Code** for collaborative, long autonomous work and richer MCP. **Codex CLI** for blunt feedback, open source, and granular permissions. Most serious indie devs end up using both — they fail on different things, and the redundancy pays for itself.
+
+If you have to pick one and you're not sure: **start with Claude Code.** Its personality is more forgiving when you're learning, and the MCP ecosystem makes it easier to extend. Move to Codex if you find yourself wishing the agent would push back more.