This Site Was Built in Less Than 10 Hours. Here's How (And Why It Gave Me an Identity Crisis)

Published: October 10, 2025 • 10 min read

The title isn't clickbait. This entire portfolio website, the one you're on right now, was built and deployed in less than 10 hours.

And honestly? It shook me.

The Identity Crisis I Didn't See Coming

After building this portfolio website, I had what I can only describe as a minor-to-major identity crisis. Since I will continue to make changes to this application, for full transparency, here is a link to the state of the website at the time this blog post is being published.

The one thing I thought I was so good at, a skill I could show off to my friends that made me feel special, suddenly didn't seem as special anymore. If I could build a comprehensive, professional portfolio site in 10 hours using AI, what did that say about my development skills? In that moment of crisis, I thought: anyone can definitely recreate this... or can they?

Now, you may be wondering: "Didn't you feel this way when you were building 65+ applications at Outlier?"

Well, here's the thing, I did. Just not to this degree.

The Difference Between Then and Now

When I was training multiple models at Outlier and comparing their performance to Claude, there were a lot of flaws and limitations in what the models produced. I genuinely enjoyed the process of guiding the models to create better products. The AI felt like a tool that needed significant human oversight and correction.

While the initial development process generally took 3-6 hours, most applications actually required 15-20 hours to be fully built. The cycle worked like this:

Attempter creates first version (3-6 hours)
Initial review stage (15-60 minutes)
Feedback and revision cycle - Most applications got sent back to the original attempter with reviewer feedback (another 3-6 hours)
Multiple review iterations - The previous two steps could repeat, or the task would pass to another reviewer whose job was to take an already good application and improve it even further (1-3 hours)
Final quality check - Senior reviewers would either approve it for customers or send it back with feedback for more refinement (30-60 minutes)

At various points, I played all the roles listed above.

Fast forward just two months. I attempted to build a portfolio website to showcase my skills, and I finished it in about 10 hours over two days, from initial concept to full deployment.

I must admit, I felt uneasy after seeing how little time it took. I've taken time to reflect on these feelings, and here are the major realizations I've come to.

Reality Check #1: Speed Doesn't Equal Simplicity

Just because it took me 10 hours to build a website that would have originally taken maybe two months using solely traditional development skills doesn't mean it'll take anyone 10 hours to do the same.

This is crucial to understand.

The speed came from a specific combination of factors that took months to develop:

Extensive experience working with HTML, CSS, and JavaScript
Deep understanding of Next.js, TypeScript, and React
65+ applications worth of prompt engineering experience
Understanding of design principles and user experience
Knowledge of what's possible (and what's not) with current AI capabilities

How My Prompt Engineering Skills Evolved

My development experience at Outlier had a significant learning curve in terms of prompt engineering skills.

The Early Days: Vague Instructions

When working on tasks where I had to craft my own prompts, my early prompting style led me to face and deal with numerous issues:

Memory issues - having to continue chats and repeat context
Inconsistent theming - styles that didn't match across components
Mobile responsiveness problems - layouts that broke on smaller screens
Accessibility gaps - missing ARIA labels and semantic HTML

The Evolution: Precision and Strategy

Now, my prompt engineering skills have evolved significantly. I've learned to not rely on AI but view it as an executor of my commands. A very precise executor, I might add.

And when you have a very precise executor, you need precise instructions.

How I Actually Built This Portfolio

When building this site, I didn't just ask Claude to "create a portfolio website." Here's my actual process:

Step 1: Strategic Planning

Because I had knowledge of Next.js, TypeScript, and React, I asked Claude to draw out a detailed plan for the website, starting with the folder structure.

I specified:

Color themes: Purple and teal as primary colors
Design trend: Glassmorphism for a modern, elegant feel
Component architecture: How sections should be organized
Responsive requirements: Fully responsive across mobile and desktop applications

Most importantly, I asked Claude to communicate its plans with me before writing any code. (I suggest checking out other modern design trends here. I particularly love glassmorphism and neumorphism.)

Step 2: Plan Review and Refinement

When I saw Claude's initial plan, I was able to identify loopholes and elements that weren't going to match my vision. I communicated these concerns, and we iterated on the plan until it was solid.

Only after we were clear on the game plan did I ask for the actual code, component by component.

Step 3: Execution and Deployment

Claude generated the code based on our refined plan, and I handled the deployment process, catching issues as they arose.

What I Would Do Differently

Looking back, here's what I failed to identify:

Claude didn't account for the fact that when building and deploying a website, I'd need to replace certain characters with their HTML entity equivalents. For example, apostrophes needed to be`'`in JSX to avoid deployment errors.

Specifying this in my initial prompt would have saved me debugging time during deployment. This is the kind of knowledge that comes from experience, knowing what to tell the AI before it becomes a problem.

What Claude Still Struggles With

Proper implementation of dark and light modes.

Now, is it possible that my initial instructions failed to guide the model properly? Yes, absolutely. Maybe I could have written a better prompt. But I'm definitely learning with every app I build using AI.

The theme system required multiple iterations and manual refinement to work correctly across all components. This is where human expertise still makes a massive difference.

The Realization That Ended My Crisis

My season of crisis is over. Here's what I understand now:

AI Doesn't Diminish My Skills, It Amplifies Them

I understand the power of prompting efficiently to generate desired results from AI while simultaneously cutting back on time. But this power comes from my existing knowledge:

I know what to ask for because I understand web development architecture
I can identify flaws in Claude's plans because I've built applications before
I can debug issues quickly because I understand how Next.js works
I can refine prompts effectively because I know what's possible
I can anticipate errors before they happen and better structure my prompts to minimize or eliminate them

I'm a Smarter, Faster Executor

AI makes me a smarter and faster executor. My ideas are brought to life more quickly because of how well I'm able to pull from my various strengths when communicating with AI.

The value isn't in typing code manually anymore, it's in:

Knowing what to build and why
Understanding how things should work together
Making strategic decisions about architecture and design
Identifying and fixing issues when they arise
Communicating effectively with AI tools to achieve precise results

What This Means for Developers

If you're a developer feeling threatened by AI, I get it. I felt it too.

But here's the truth: AI isn't replacing developers. Instead, it's changing what being a developer means.

The skills that matter now:

Systems thinking - understanding how pieces fit together
Problem decomposition - breaking complex problems into clear steps
Prompt engineering - communicating technical requirements precisely
Quality evaluation - knowing good code from bad
User experience - understanding what makes software valuable
Debugging and refinement - fixing what AI gets wrong

These aren't skills you can just pick up overnight. They come from experience, from building things, from failing and learning. More than ever, I understand the importance of extensively studying documentation for any programming languages or tools you work with. This way, you're exposed to all (or most of) what's possible with that tool. Then you can effectively communicate with the model to bring your ideas to life using those tools.

The 10-Hour Portfolio Wasn't Magic: It Was Experience

This portfolio took 10 hours to build, but that's misleading.

It actually took:

4 months of building 65+ applications to understand AI capabilities
Years of learning web development fundamentals
Months of studying design principles and user experience
Countless hours debugging and refining my prompt engineering approach

The 10 hours was just the visible part of years of accumulated knowledge coming together with the right tools.

Moving Forward: Embracing the AI-Enhanced Future

I'm no longer in crisis about what AI means for my career. Instead, I'm excited.

Because while AI can execute my instructions with precision, it still needs someone who:

Knows what instructions to give
Understands when the output is wrong
Can refine and improve the results
Brings creative vision and strategic thinking

That's where the real value lies. And that's what I bring to the table.

AI doesn't make me less valuable as a developer. It makes me capable of building things at a speed I could only dream of before.

And honestly? That's pretty special.

This post is part of my "Technical Reflections" series, where I share honest thoughts about the changing landscape of software development and what it means to build things in the age of AI.