Embracing AI: How Engineers Will Actually Work Now

This weekend I upgraded my blog from Astro 3 to 5, overhauled the entire CSS system, implemented a new design system, and shipped to production. I didn’t write a single line of code myself.

I know what some of you are thinking: “AI can’t really do that. It hallucinates. It writes broken code. You end up spending more time fixing its mess than just doing it yourself.”

I used to think the same. A year ago, that was my experience too.

But AI has evolved. And engineers who embrace it will find themselves working very differently.

What Changed?

A year ago, working with AI meant constant course-correction. You’d ask for a feature, get something half-right, spend time fixing hallucinations, removing unwanted code, undoing “improvements” you didn’t ask for. The net productivity gain was questionable. I wrote about this in why coding with LLMs can be harder than you think.

But tools have matured. Models have improved. Claude Code with Opus 4.5, combined with plugins like Superpowers, now maintains context across long sessions, follows structured workflows, and doesn’t go off on tangents. The experience is fundamentally different.

So when I decided to upgrade my blog, I approached it differently.

The Task

My blog (niraj.life) had been running on Astro 3.6 with Tailwind 3.3 for a while. It worked, but the CSS situation bothered me - too many overrides, inconsistent colors, manual styling everywhere. The kind of tech debt that nags at you every time you open the codebase.

I wanted three things:

Upgrade to latest Astro and Tailwind
Implement a proper design system (monochrome + electric blue accent)
Kill the custom CSS - ideally get to zero

The old me would’ve spent a weekend reading migration guides, manually updating files, debugging breaking changes, and tweaking CSS until it looked right.

Instead, I opened Claude Code and let AI handle it.

The Interaction Model

Here’s what’s different about how I work with AI now versus a year ago.

Old approach: “Implement this API.” “Add a button here.” “Write a function that does X.”

New approach: “Here’s my problem. Help me figure out the solution.”

I didn’t tell AI to upgrade to Astro 5. I told it my blog felt outdated, the CSS was a mess, and I wanted to modernize it. I was genuinely open to solutions - if AI had reasoned that migrating to Next.js made more sense, I would’ve considered it. But I wanted the reasoning, not just a recommendation.

And that’s exactly what happened. AI analyzed the current stack, considered alternatives, and explained why staying with Astro but upgrading made sense for my use case. It wasn’t just executing commands - it was thinking through the problem.

The Back and Forth

The session was full of questions - from both sides.

AI asked: “What’s your goal - just upgrade, or rethink the whole thing?” I said both. It asked about my pain points. I vented about CSS overrides, color inconsistencies, font issues.

Then it gave me options for visual direction. I picked “Personal Operating System / Performance Lab” vibe. It asked about color schemes - I picked monochrome + electric blue. Typography? Monospace headers, system sans body. Fonts? System fonts for maximum performance.

My role was setting boundaries and ring-fencing AI’s creativity. When it suggested options, I picked. When it went too far, I pulled back. When something felt off, I said so.

It felt exactly like how a Product Owner works with a Developer - I owned the “what” and “why”, AI owned the “how”.

Notice what’s happening here - I wasn’t discussing code. I was discussing product. What should this look like? What’s the vibe? What matters to me?

Once the direction was clear, AI wrote a design document, set up a git worktree for isolation, created an implementation plan with 13 tasks, and started executing - one task at a time, checking in with me along the way.

How It Actually Worked

Here’s what struck me during this session: I was communicating intent, not implementation details.

I didn’t say “use prose classes from Tailwind Typography plugin.” I said “I want zero custom CSS if possible.” AI figured out the how.

I didn’t say “update the tailwind.config.mjs with extended colors.” I said “monochrome with electric blue accent.” AI translated that into design tokens.

When the about page looked narrower than blog posts, I didn’t debug the CSS. I just said “the container looks smaller here.” AI found the issue and fixed it.

I provided intent. AI provided implementation.

This is what embracing AI looks like. You’re still the engineer - you understand the system, you know what good looks like, you catch when something’s off. But you’re not typing every line yourself. You’re guiding, reviewing, deciding.

The Superpowers plugin added structure that made this smooth - brainstorming workflows to clarify requirements upfront, git worktrees to isolate changes, implementation plans to track progress. It felt less like chatting with a bot and more like working with a capable junior engineer who just needed direction.

What Actually Got Done

By the end of the session:

Astro upgraded from 3.6.4 to 5.17.1
Tailwind upgraded from 3.3.6 to 3.4.19 with Typography plugin
global.css went from 119 lines to 13 lines
New design system with proper dark mode
System fonts instead of web fonts (zero font loading)
All 202 pages building successfully
Merged and deployed to production
PageSpeed score: 90+, almost hitting 100

The whole thing - from “I want to upgrade my blog” to live on production - happened in one session.

The Engineer’s Evolution

I’ve been writing about AI-assisted coding for a while now - from why coding with LLMs can be harder than you think to pair programming with AI. My earlier narrative was cautious: AI helps, but you still need to babysit it.

That’s changing. The tools have caught up to the promise.

Engineers who dismiss AI as “just a chatbot” or “too unreliable” are working with outdated assumptions. The models from a year ago? Yes, they were frustrating. The current generation? Different game.

This isn’t about AI replacing engineers. It’s about engineers who embrace AI working at a different level:

You still need to understand systems and architecture
You still need to catch when something’s wrong
You still need to make good technical decisions
But you don’t need to type every line yourself

The engineers who lean into this will get more done. Not because they’re smarter, but because they’ve accepted that the craft is evolving.

If you’ve written off AI coding tools based on experiences from a year ago, it might be time to try again. Not with a toy project - with something real. The friction you remember might not be there anymore.