One day of prompting for a production-ready portfolio. I knew exactly what to ask for.
The Setup
What I saw: v0.dev templates at an AWS event locked to Vercel's framework.
What I knew: Astro exists. Directus exists. Hono exists. I'd learned them through tech events, forum diving, building small experiments.
What happened: Sonnet 4.5 drops. One day of focused prompting. Working Astro variant with Directus CMS. Production-deployed.
Why it worked: Curation and taste. Not because AI figured it out.
What AI Gives You Without Direction
Left to its own devices, Claude Code suggests:
The default stack:
- Express (because it's popular)
- Basic JavaScript (because it's simple)
- Hardcoded data (because it works)
- Generic placeholders everywhere
What you get: Something that runs. Nothing you'd ship.
This is the trap: AI coding tools work, but they optimize for "runs quickly" not "production-grade."
What Changes with Curation
When you know what exists, you can prompt differently.
Without curation:
"Build me a portfolio site"
Result: Next.js with hardcoded content. Generic. Forgettable.
With curation:
"I have a v0.dev template. Convert it to Astro. Use Directus for content management. Lightweight API layer between them. Type-safe."
Result: Production architecture in a day.
The difference: I knew Astro, Directus, and Hono existed. I'd seen them at events, experimented with them in small projects, understood their trade-offs.
Where I Actually Learned
Tech Events
Seeing Vercel demo v0.dev at AWS. Watching the framework lock-in. Thinking: "Great UI, wrong stack for my needs."
Hallway conversations about Directus. Someone mentioning Hono's edge-ready architecture. Filing it away.
The Internet Annals
Forum threads about Astro vs Next.js for content sites. Blog posts comparing headless CMS options. GitHub issues showing real integration patterns.
Not tutorials. Real people discussing real trade-offs.
Small Experiments with Claude Code
Building throwaway projects:
- "Show me how Directus works"
- "What's the Hono API surface look like?"
- "How does Astro handle dynamic routes?"
Rudimentary understanding. Just enough to know what's possible.
The Moment of Synthesis
v0.dev templates are beautiful. But I wanted:
- Astro (better for content than Next.js)
- Self-hosted (not Vercel-locked)
- Directus (better admin UI than competitors)
- Hono (lighter than Express)
The key: I could name these choices. Claude Code didn't suggest them. I directed it toward them.
What One Day of Prompting Looks Like
Morning: The Conversion
Me: "This v0.dev template is Next.js. Convert the component structure to Astro. Keep the design, swap the framework."
Claude Code: Converts components. Shows me incompatibilities. We iterate.
The difference from generic: I knew to ask for Astro specifically. I knew what I was trading (React interactivity for static speed).
Afternoon: The Integration
Me: "Now integrate Directus. I need a content adapter pattern—Astro expects content collections, Directus is an API."
Claude Code: Implements the adapter. Type-safe throughout.
Why this worked: I knew the pattern name. I'd seen it discussed in Astro forums. Claude Code filled in syntax, but I directed architecture.
Evening: The Deployment
Me: "Docker Compose. Frontend, API, Directus. Healthchecks so they start in order."
Claude Code: Generates docker-compose.yml. We debug networking.
The curation: I knew Docker Compose (not Kubernetes) because I'd learned the trade-offs at tech events. Claude Code wrote the config, but I chose the tool.
The LLM-Driven Issue Loop
This is where Sonnet 4.5 shines:
Pattern:
- Build a feature
- Test it
- Hit an error
- Paste error to Claude Code
- It suggests fix
- Repeat
Example:
- Docker services can't reach each other
- Paste error logs
- "Add them all to the same network"
- Works
Why this is different: Earlier models would explain Docker networking. Sonnet 4.5 just fixes it. One-shot solutions instead of educational detours.
But here's the key: I knew enough to recognize good solutions. When it suggested healthchecks, I understood why. When it chose Traefik labels, I knew what they did.
Curation isn't just choosing tools. It's evaluating AI suggestions.
What Curation Actually Means
1. Knowing What Exists
I can't ask for Hono if I don't know it exists. I learned it from:
- Tech event hallway conversation
- Seeing it on a "lightweight Node frameworks" list
- Building a throwaway API to understand it
The work: Self-directed learning. Tech events. Experimentation.
2. Understanding Trade-offs
When Claude Code suggests Express, I know to push back: "What about Hono?"
When it suggests Strapi, I counter with: "Directus has a better admin UI."
The knowledge: Not from AI. From forums, GitHub issues, comparing tools myself.
3. Recognizing Good Architecture
Claude Code suggests the content adapter pattern. I recognize it's solid because:
- Separates concerns
- Keeps Astro pages clean
- Makes CMS swappable
The judgment: Built from seeing patterns in real codebases, not from AI explanations.
4. Directing, Not Just Accepting
Default: "Build me X" → AI chooses everything
Curated: "I want A, B, C integrated. Show me how" → You choose, AI implements
The difference: Agency. You're in control.
Why This Moment Matters
The Timing
Anthropic bets big on coding AI: Sonnet 4.5 is noticeably better at multi-file edits, integration patterns, configuration generation.
Production-grade tools mature: Directus, Hono, Astro are all stable. Not experimental.
v0.dev shows the demand: People want beautiful templates. They just don't want framework lock-in.
Confluence: I have the curation. AI has the capability. Tools are production-ready.
What Makes This Reproducible
Not "use these exact tools."
But: Build your curation muscle, then execute with AI.
How to build curation:
- Go to tech events (see tools demoed, hear hallway chatter)
- Dig through forums (understand why people choose X over Y)
- Build small experiments (gain rudimentary understanding)
- Develop taste (know when "good enough" vs "production-grade")
Then when Sonnet 4.5 (or better) exists:
- You can name what you want
- AI handles implementation details
- One day of focused work = production site
The Honest Comparison
Without Curation
Prompt: "Build me a portfolio site"
Result: Express + basic JS + placeholders
Time to production: Weeks of refactoring to make it real
With Curation
Prompt: "Convert this v0.dev template to Astro. Integrate Directus. Use Hono for API. Docker Compose deployment."
Result: Production-grade architecture from day one
Time to production: One day of focused prompting
The difference: I did the learning beforehand. AI does the implementation now.
What You Actually Need to Learn
Not from AI:
- What tools exist in the ecosystem
- Why people choose specific tools
- Trade-offs between options
- What "production-grade" looks like
From AI:
- How to integrate specific tools
- Configuration syntax
- Implementation patterns
- Fixing specific errors
The split: Strategic knowledge is yours. Tactical execution is AI's.
The Pattern
Phase 1: Self-Directed Learning
- Attend tech events
- Read forums and GitHub issues
- Experiment with tools in isolation
- Develop opinions about trade-offs
Phase 2: Small Experiments
- Build throwaway projects with Claude Code
- Gain rudimentary understanding
- Learn what's possible, what's hard
Phase 3: Recognition
- "I know what I want to build"
- "I know which tools fit together"
- "I can direct an AI toward this vision"
Phase 4: Execution
- One day of focused prompting
- LLM-driven issue loop (error → fix → repeat)
- Production-grade result
The Result
Live: https://b28.dev
Timeline:
- Months of learning (events, experiments, forums)
- One day of building (prompting + iteration)
Stack: Astro, Hono, Directus, PostgreSQL, Docker, Cloudflare Tunnels
Why these choices: Not AI suggestions. My curation from tech events and self-directed learning.
Why one day: Because Sonnet 4.5 is good at implementation when you direct it well.
The Real Unlock
2023: You needed to know how to build it yourself. AI helped with boilerplate.
2025: You need to know what to build and why. AI builds it for you.
The skill that matters: Curation. Knowing what exists, what fits together, what's production-grade.
How you build that skill: Tech events. Forum diving. Small experiments. Developing taste.
When AI amplifies it: When you can say "I want A, B, C integrated" and the AI handles implementation.
The tools haven't changed. The leverage has.
Template credit: Felix Macaspac's v0.dev minimalist portfolio
Real methodology: Curated architecture + AI implementation = one-day production deploy