Building a Developer Portfolio in a Weekend With Gemini 3.8 Flash High

Plenty of experienced developers share one slightly embarrassing habit: years of JavaScript, TypeScript, React, Next.js, Node.js, Java, Python and cloud work, and a personal portfolio that never gets finished. It's rarely a technical problem. It's the classic "later, when there's time" trap, and time never shows up.

One way out is to change the method. Rather than spend days designing components and typing every line, a developer can hand the first pass to an AI coding agent. Here the setup was Antigravity with Gemini 3.8 Flash High, on a weekend afternoon. The aim wasn't another generic AI template. It was a site that felt personal, and the result beat expectations.

A deliberately small brief

The portfolio had to say three things fast: full-stack engineer, builder of modern web architectures, and growing focus on AI, agents and emerging developer tech.

It also had to avoid the usual template: hero, 47 skill badges, 12 project cards, a giant résumé, a greeting about being a passionate developer, contact form, footer. The final structure was much leaner:

• Full-screen hero
• Newsletter call to action
• Selected work
• Top technologies
• Writing and publishing
• Experience
• Minimal footer

No résumé dump, no endless carousel, no filler sections.

Design first

The visual direction was settled before Gemini wrote anything: dark, cinematic, modern, developer-focused, minimal, spacious and personal.

The hero mattered most. A stock developer illustration was out. The goal was a picture of the actual person at a workstation, so the final hero is a dark cinematic scene with a portrait blended into it. It fills the whole viewport, which sounds minor and changes a lot, because the first screen reads as an introduction instead of a site header. A small scroll indicator at the bottom center shows there's more below.

Handing Gemini the whole vision

Here's where it got interesting. Gemini didn't receive step-by-step requests such as "create the navbar", then "now the hero", then "now the project cards". It received the entire product vision at once. The stack was simple: Next.js and Tailwind CSS.

The prompt covered:

• background
• technology stack
• projects
• writing
• experience
• visual direction
• branding
• responsive requirements
• content hierarchy

Gemini then produced the first implementation.

The first version was never going to be perfect

And it shouldn't be. Some icons were placeholders, some brand marks were approximations, and some article entries had to be swapped for the real ones.

This is where the mindset around AI coding has to shift. The expectation isn't "AI generated perfect code." It's "AI produced a strong first implementation that a person can review, direct and refine." Those are very different claims.

Don't let the model invent who you are

Content accuracy was one of the sharpest lessons. On a portfolio, hallucinated content does real damage. A made-up project blurb might look harmless, but a fake article, a wrong GitHub link or an invented work history is not harmless at all.

So the real links and content were supplied by hand. Let AI generate the implementation, and don't let it make up your identity.

Real icons for the technology section

The first technology section used placeholder-style icons, which wasn't good enough. If the page lists JavaScript, TypeScript, React, Next.js, Docker, PostgreSQL and GitHub, it should show the real logos. So Gemini was told explicitly which sources to use: Devicon for developer technologies and React Simple Icons for broader brand icons. A genuine logo beats an AI approximation of one.

Responsive design was a pleasant surprise

After deployment the site was checked on desktop, then mobile, and both looked fine. Tablet came out better than expected, and tablet is usually the awkward breakpoint. Desktop layouts shrink, mobile layouts stretch, and the in-between size exposes bad assumptions. This one held up across all three.

It points to something beyond generating code faster: with clearly stated requirements, AI can produce a reasonable first-pass responsive system. That doesn't remove testing. It makes testing more valuable.

Security before deploying

The site wasn't published straight away. Before deployment the checks covered:

• known vulnerabilities in dependencies
• hardcoded keys, tokens and passwords
• environment variables and private keys
• phone numbers, email addresses and internal URLs
• any other accidental secret
• sensitive data lingering in Git history

Keep one distinction in mind. A public portfolio can deliberately include your name, GitHub, LinkedIn, article links and professional details, and that's not a security problem. Accidentally shipping something like this is a different matter:

API_KEY=...
DATABASE_PASSWORD=...
PRIVATE_KEY=...

AI-generated apps still need ordinary engineering discipline.

Shipping it

The finished app went live on Vercel. That's when the experiment became real. The point isn't that Gemini generated some code. It's that someone described a product, iterated on it, validated it and shipped it, which is a more useful way to think about AI-assisted development.

How much of the allowance did it use?

Gemini 3.8 Flash High handled the whole workflow in Antigravity. Afterward the usage dashboard showed 90% of the weekly limit remaining and 37% of the five-hour limit. That isn't a scientific benchmark, and prompts, context sizes, models, agent behavior and projects will give very different numbers. As a personal data point it's still interesting: the path ran from nothing, to a designed portfolio, to a responsive implementation, iterative fixes, a security review and a production deployment, inside a weekend and without draining the weekly allowance.

What the weekend taught

The takeaway isn't that Gemini can build websites, since that's known. It's about how you use it.

1. Your prompt is part of the architecture. A vague prompt gives a generic site. One that spells out design constraints, content, architecture, technologies, responsive behavior and boundaries gets you much closer to what you want.
2. AI is good at implementation and has no authority. Gemini can decide how to build a card. It shouldn't decide your career history, which projects you built, which articles are yours or which links belong to you. Those are source-of-truth questions.
3. Iteration beats perfection. The flow wasn't prompt, then perfect site. It was prompt, implement, inspect, correct, refine, validate, deploy, which is much closer to real engineering.
4. Leave working things alone. Once the portfolio looked right, the "make it better" requests stopped. Agents are great at changing things, and that doesn't mean everything needs changing.

Would this work for every project?

For a marketing site, portfolio, landing page, prototype or content-driven app, this approach can be very productive. For production systems that involve payments, authentication, sensitive data, complex business logic or distributed systems, AI should be used very differently, with firmer control of the architecture and far more testing, threat modeling, review by people and manual verification. As the stakes of the software rise, handing the agent the keys makes less and less sense.

What the experiment really tested

The portfolio was a vehicle. What got tested was a workflow. Time went less to typing components and more to these questions: what should exist, why, what should it look like, what must not change, and which information is authoritative. The agent handled much of the implementation.

That's a real shift for engineers, from writing every line toward directing, reviewing, validating and shipping systems. It doesn't make engineering less important. It makes engineering judgment more important.

Speed wasn't the interesting part. What stood out was the share of effort that shifted away from keystrokes and into judgment calls. AI-assisted development gets compelling when a developer can describe an idea clearly, steer an agent through the build, catch its mistakes, protect the key constraints and still own what ships, not when a model writes 10,000 lines. The AI didn't build the portfolio alone. It was directed, reviewed, corrected and shipped by a person, and for a weekend experiment that's a good outcome.