Show Notes
Claude Code unlocked a fast, multi-agent workflow to turn ideas into working prototypes. Here are the core takeaways, plus the concrete builds from today.
What I covered (in brief)
- Exploring Claude Code with parallel agents to scale thinking, plan, and implement across multiple projects.
- Real-world demos: a content inspiration bot, a bedside hardware concept, a YouTube assistant, and a CMS prototype that ties Claude into a blog workflow.
- Practical prompts, anatomy, and prompts structure that shift how much context you hand Claude and how you extract results.
Parallel agents and prompting workflow
- Think and plan structure
- Use extended thinking prompts to trigger deep reasoning (think / ultra think).
- Use a dedicated “Plan” step to map out phases and tasks before execution.
- Anatomy of a prompt (based on Boris’s docs)
- Begin with a directive to use parallel agents to investigate issues.
- Increase thinking budget with specific phrases to unlock deeper analysis.
- End with a concrete plan and assignable actions.
- Subagents vs. single-agent flow
- Subagents help disperse context across many files or modules, avoiding a single giant prompt.
- Good for large refactors or cross-cutting issues that touch many parts of the codebase.
- Practical prompt tips
- Use dot-commands for arguments to pass structured data into prompts.
- Structure prompts to guide discovery, analysis, and actionable outcomes (audit, document, implement).
- Scaling context thoughtfully
- Don’t blow the context window; slice work into phases and assign agents accordingly.
- Example: a 53-file refactor across 4 front-to-back areas (hooks, queries, routers, schemas) can be split among parallel agents.
Code snippet (prompt pattern idea)
# UltraThink
Use parallel agents to investigate these issues, then come up with a plan to solve them.
Think hard. Think harder. Ultra think.
Plan:
- Phase 1: Audit codebase for X
- Phase 2: Propose Y changes
- Phase 3: Implement and verify
Projects I built today (highlights)
- Content inspiration repository (left-side panel)
- Auto-grabs Simon Willis’s vibe coding article, analyzes style, and surfaces external links and references.
- Bedside hardware automation (concept)
- A mock hardware button to control the bed via a proxying setup (man-in-the-middle proxy) to visualize Claude-driven automation concepts.
- YouTube assistant inside Claude Code
- A tool that shows function calls and the corresponding prompts, wired up in a way you can test without writing new code.
- CMS prototype connected to Bear notes
- Explore turning Bear notes into a live CMS by syncing tagged content with a SQLite-backed store, then exposing content via a minimal site.
- MDX-powered analyses for prex.com/ressearch
- MDX components render dynamic insights on the site, driven by Claude-driven analysis, so you get evolving content without heavy UI work.
How I used Claude to accelerate development
- Read the docs and relevant research to ground workflows
- Implementable patterns come from documentation, researcher vibes, and real-world examples.
- Break tasks into repeatable patterns
- A repeatable pattern across 53 files helped orchestrate a large refactor without chaos.
- Use clean, testable outputs
- The system produced audit results, documentation drafts, and concrete improvement plans you can review and implement.
Core learnings and best practices
- Structure your prompts for outcomes, not just questions
- Start with intent, then think, plan, act, and verify.
- Use parallel agents for multi-file or cross-cutting tasks
- Better coverage, less context loss, and more scalable reasoning.
- Don’t over-egg the context window
- Break work into phases; let agents handle discrete chunks and re-assemble results.
- Leverage documentation and research
- You don’t have to be a researcher to adopt solid practices—read, adapt, iterate.
- Real-world caveats
- Watch for overzealous automation that creates brittle setups; test incremental changes and validate outputs.
How you can apply this to your projects
- Start with a single, well-scoped problem
- Define a clear goal, then apply think/plan with parallel agents to explore options.
- Build repeatable patterns
- Create a template prompt for audits, docs, or feature implementations to reuse across PRs.
- Tie Claude into your workflow
- Use a local CMS, notes, or docs as a testbed; generate docs or tickets automatically from analysis.
- Visualize outputs with lightweight UI
- Pair Claude-generated plans with simple MDX components or dashboards to share insights.
Takeaways for next steps
- Read, then prompt intentionally
- The best gains come from structured prompts and disciplined thinking prompts.
- Start small, scale with subagents
- If you’re new to Claude Code, begin with a narrow scope; scale up with subagents for larger refactors.
- Iterate and document
- Use Claude to audit, document, and propose concrete improvements; then implement in code.
Links
- Claude Code docs and guides
- Simon Willison – Vibe Engineering
- Drizzle ORM (database layer)
- tRPC (type-safe APIs)
- Bear notes (note-taking + CMS integration concept)
- SQLite in macOS (application support / data syncing)
If you want a quick-start prompt you can copy, I’ll post a clean template from today’s session in the comments.