A few weeks ago I decided I needed a portfolio site. Something that showed what I've actually built, not just a LinkedIn profile. Yesterday it went live on a custom domain. Total build time: somewhere between five and ten hours across short bursts of work.
The stack is Next.js, TypeScript, Tailwind CSS, and shadcn/ui components. I couldn't write any of that from scratch. I have no formal software engineering background. But I'm an analytical thinker who breaks problems down until they make sense.
Tech Stack
Framework
Styling
AI Tools
Deployment
What I built
A single-page portfolio site. Smooth scroll navigation with active section tracking, hover-animated cards, impact metrics with before/after comparisons, a career timeline, and a contact section. Responsive across devices. Deployed on Vercel with a custom domain.
I built it using Cursor IDE and Claude Code. Claude Opus 4.5 handled most of the implementation, which burned through my monthly Cursor limit fast. Worth it.
The commit history tells the story. An initial scaffold, then dozens of iterative refinements. Component tweaks, content restructuring, performance passes. Normal for an experienced developer. Entirely new territory for me.
What went well
- Rapid prototyping: I had a working site within the first session. That meant I could iterate on something real, not theoretical
- AI as teacher: when I hit unfamiliar concepts, I asked questions. Why structure components this way? What are the tradeoffs? The models helped me get technical enough to make real decisions
- Structured plans: writing markdown specs for each change (what's wrong, what it needs to do, what "done" looks like) made the AI output dramatically better
What didn't
- Vague prompts produce vague results: whenever I was unclear about what I wanted, the output missed the mark. Precision in the brief was everything
- Visual polish is slow: getting UI elements to look exactly right required many back-and-forth cycles over small details
- Domain setup: linking the custom domain to Vercel was a frustrating detour unrelated to the actual build
Build Process
Idea
Define what the site needs to do
Markdown Plan
Structure requirements in detail
AI Builds
Claude Code implements the plan
Review & Refine
Check output, adjust, iterate
Deploy
Ship to Vercel
How the build actually worked
Planning mattered more than coding ability. That was the key insight.
Before handing anything to an AI agent, I needed to know what I wanted. Not vaguely. Specifically. What each section should contain, how components should behave, what constraints to respect. The clearer the plan, the better the output.
The pattern that worked
Create a markdown file for each change. Specify the component, what's wrong with the current state, what the new version needs to accomplish, constraints to respect, and what "done" looks like. Then hand that to the AI to implement.
I also used AI during the planning stage itself, not just for execution. I'd talk through every aspect of the build with Claude to pressure-test my thinking before committing to an approach. Ask it to poke holes in my ideas. Refine, then repeat.
Planning Workflow
The structured approach that made AI-assisted building work.
Define the problem
What does this need to do? Who is it for?
Structure requirements
Components, sections, content, interactions
Write constraints
Responsive, accessible, match animation style
AI implements
Hand the structured plan to Claude Code
Review & iterate
Check output, refine, repeat
Key takeaways
The biggest lesson from this build: for projects like this, the barrier has shifted.
The Inversion
Before
Hard
Writing code, configuring servers
Easy
Having ideas
Now
Easy
Implementation via AI
Hard
Planning, structuring, articulating
The hard part used to be technical execution. Writing the code, knowing the frameworks. For a portfolio site, that barrier is dramatically lower now. Programming becomes thinking at an abstraction level above syntax writing. It becomes system thinking, logic, analytical problem solving. Focusing on the problem to be solved, instead of the deep syntactic details of your chosen language.
That said, scope matters.
Know the boundaries
A portfolio site is not a payments system. It's not authentication infrastructure. The execution barrier lowers for certain categories of work. It doesn't eliminate the need for deep expertise where correctness and resilience matter.
My goal isn't to ship once and move on. It's to become technical enough to own what I build. Maintain it, debug it, and know when I'm out of my depth. This is a starting point. The next things I build will be more complex: automations, AI tools, eventually agents.
What I'd do differently
- Start with content, not design: I spent time on component styling before the copy was final, then had to redo layout work when content changed
- Commit more often: smaller, more frequent commits would have made it easier to roll back when something broke
- Set up the domain first: getting deployment and DNS sorted before building would have avoided the mid-build detour
- Write the brief before opening the IDE: every session where I started with a clear written plan went better than sessions where I improvised