Every version of my portfolio has taken months.
Not because building a portfolio takes months. Because making decisions takes months.
I'd spend weekends redesigning the hero, rewriting components, swapping fonts, deleting entire sections because they felt wrong, then eventually lose momentum around week six. By the time I shipped, I was already thinking about what I'd change next.
Version 4.0 shipped in a weekend.
Not because I suddenly became ten times faster.
Because I stopped confusing typing with building.
The realization
For years, I thought software looked something like this:
Idea → Code → Product
This project forced me to realize it actually looks more like this:
Idea → Decision → Feedback → Decision → Feedback → Code
Code was just the slowest part.
Once implementation stopped being the bottleneck, I spent almost all of my time doing something I'd always considered the 'real' work: making decisions.
Editor, not typist
I used Claude as my implementation partner, but I never handed over the creative direction.
I'd describe an interaction. It would build it. I'd hate it. We'd try again.
Sometimes that loop happened five times. Sometimes thirty.
Most conversations weren't about code at all.
They sounded more like:
"The typography feels expensive, but the layout doesn't."
"The animation is technically impressive, but it's asking for too much attention."
"This feels clever. It doesn't feel good."
Those aren't programming problems. They're design conversations.
The code appeared almost instantly.
Taste still took hours.
What actually got built
The finished site is almost suspiciously small.
- Next.js 16
- Tailwind CSS v4
- Motion
- Lenis
- Lucide React
That's essentially the entire production stack.
No CMS.
No component library.
No global state.
No UI framework.
Twenty-eight files spread across sections/, ui/, and fx/.
I wanted something I'd still understand six months from now without opening twenty browser tabs.
The most interesting parts weren't the ones that shipped. They were the ones that almost did.
Matrix Rain
The first version literally rained my own source code down the screen.
It sounded clever.
It looked like a GitHub screensaver.
It pulled attention away from everything that mattered.
We threw it away and rebuilt the entire effect using katakana characters, digits, cursor heat distortion, and click ripples.
Less clever.
Much better.
The CRT terminal
The About section became an old CRT monitor.
Not because retro is trendy.
Because I wanted the page to feel alive before anyone interacted with it.
The scanlines, phosphor glow, animated static, and glitch effect are all rendered in canvas.
The best part isn't visible in a screenshot.
Move your cursor slowly and the monitor behaves.
Move quickly and it starts falling apart.
That's the kind of interaction people rarely notice consciously.
Which is exactly why I like it.
The journey timeline
The first timeline was a giant SVG road that literally drew itself as you scrolled.
Desktop?
Beautiful.
Mobile?
Completely unusable.
Six years ago I would've spent another weekend trying to save it.
This time I deleted it in five minutes.
That's one of the biggest mindset shifts AI gave me.
When rebuilding is cheap, deleting stops being painful.
AI didn't save me time
This might sound strange, but I don't think AI actually saved me that many hours.
I probably spent about the same amount of time on this portfolio as previous versions.
The difference is where those hours went.
Before:
- 80% implementation
- 20% refinement
Now:
- 20% implementation
- 80% refinement
Instead of wrestling with syntax, I spent my time experimenting.
I rejected around sixty font combinations before settling on Gabarito, DM Serif Display, and Space Mono.
I built and deleted an AI portrait effect.
A Projects section.
A giant contact page.
A metrics dashboard.
None of them were broken.
They just weren't right.
AI didn't remove iteration.
It made iteration almost free.
Where AI still falls short
AI has a default aesthetic.
Rounded cards.
Soft gradients.
Polished animations.
Generous spacing.
It's pleasant.
It's also forgettable.
Left alone long enough, every AI-generated interface starts looking suspiciously similar.
That's where experience still matters.
Knowing when an interaction feels distracting instead of delightful.
Knowing when a page is technically impressive but emotionally flat.
Knowing when to delete something that's objectively 'good' because it isn't right for the product.
The only recurring problem that had nothing to do with taste was Turbopack occasionally serving stale CSS after changes to globals.css. The page would update, the styles wouldn't, and it looked like nothing had happened. It took longer than I'd like to admit to realize I needed to inspect the compiled output instead of assuming the source was the problem.
The bigger shift
I don't think AI replaces developers.
I think it changes where developers create value.
The valuable part of software was never typing React components.
It was deciding what deserved to exist.
Choosing the interaction that feels effortless instead of impressive.
Deleting good ideas in search of better ones.
Making hundreds of tiny decisions that no benchmark will ever measure, but every user somehow notices.
Six years ago, building software meant turning ideas into code.
This weekend felt different.
It felt like turning ideas into decisions.
The code just happened in between.
I didn't become a better engineer overnight.
I simply stopped spending most of my time doing the least valuable part of the job.
Typing was never where the value lived.