I once resisted AI, and almost missed the wave

Introduction

Today, many people know me as “the AI guy”. I’ve been recognized in my company for contributions in this area, I work daily with tools like Cursor and Codex, and I share lessons on how to use AI to boost developer productivity.

But believe it or not: back in 2023, I was skeptical and resistant. I tried ChatGPT and Copilot in VS Code, found them primitive, frustrating, and thought: “this isn’t for me, it’ll never help me”. So I ditched it.

Looking back now: big mistake. While I was fighting the tide, my peers were already surfing it. I lost time, missed opportunities, and eventually had to run to catch up.

My first experience with AI

My debut was with Copilot in 2023. It suggested snippets of code — but most of the time, I had to rewrite them from scratch. I asked for one thing, got something else. The result: friction, frustration, and the impression that it was just a hype toy.

At the time, my thoughts were:

• “If it doesn’t work the first time, it’s useless”.
• “If it can’t understand me, it’s incapable”.
• “I’m faster doing it myself”.

And, like many people who jump to conclusions, I just walked away. I stopped using it for months.

The cost of resistance

Meanwhile, my friends kept experimenting. Every week I’d hear things like “I built a prototype in hours”, “I had AI review my code”, “I gave it another try — it’s way better now”.

And me? I was stuck in my first impression. My reasoning was: “If it didn’t work once, it won’t work ever”. That was my biggest mistake: assuming technology is static. In reality, AI evolves at an absurd speed.

The turning point

When I came back, I noticed two things:

1. The models had improved massively. Copilot wasn’t just spitting random snippets anymore. The results felt sharper and more consistent.
2. I also had to improve. It wasn’t about opening the editor and waiting for magic. It was about structuring my asks better and using AI as a partner — not as someone who “does it all for me”.

That mindset shift changed everything.

Real impact

With Cursor + Codex, I’m now about 60% more productive.

• What once took me a week now takes a few hours.
• Side projects that used to cost nights and weekends now fit into a single day.
• Prototyping an app or idea is basically automated.

Example: In 2023, a simple app prototype took me 7 workdays (setup, boilerplate, logic, cleanup). In 2025, I built the same complexity in 6 hours with AI. That’s not just productivity — it’s a complete shift in how I approach projects: from “should I invest a week?” to “let’s validate this idea today”.

My AI usage techniques

Over time, I realized there’s no “one-size-fits-all”. The key is adapting techniques to the context. Here’s how I actually use AI:

1. Prototyping / Zero-to-one

When I start something from scratch, AI is basically my full-time pair. The goal: test ideas fast without drowning in setup.

• Tech base: ask AI to spin up a skeleton using TanStack Start with Supabase for auth, database, and APIs.
• DX-first approach: I don’t describe in plain English. I show with code how I expect to consume the component:

<Button variant="primary" loading onClick={handleClick}> Save </Button> 

This makes my expectations crystal clear.

• Temporary tests: I then ask AI to generate tests for this expected usage. They’re not meant to live forever — but they give me confidence that the initial implementation works and the developer experience (DX) I envisioned is actually there.
• Refinement: once tested, I start refining the design system — API details, loading states, accessibility, UX/UI polish.
• Clean-up: when I hit a stable version, I discard those detail-heavy tests. They’re perfect for the prototyping → production transition, but long-term they’re maintenance nightmares.

Outcome: in just a few hours, I have a navigable MVP with validated DX, ready for iteration.

2. Large, mature codebases

This is the minefield. Large codebases have their own established patterns. AI defaults to its own patterns — and they often don’t match.

I see three paths:

1. Feed tons of context: works, but expensive and clunky.
2. Refactor the base to align with AI-friendly patterns: doable, but time-consuming.
3. My go-to: break work into small blocks.

My method: split tasks into isolated functions/modules, have AI generate small pieces, and I manually integrate them back into the project. It keeps me in control while avoiding weird “AI-invented” patterns.

3. Drafts and brainstorming

I use AI as my thinking partner: drafting test cases, exploring flows that might never make it to prod, and brainstorming API contracts, naming, and edge cases.

Example prompt: “List 10 edge cases for this file upload endpoint”. Alone, I’d never cover them all. With AI, I validate much faster.

4. When to use and when to avoid

• Starting fresh: go all-in with AI, it shines.
• Legacy base: block-by-block approach.
• Critical production code: let AI draft, but refine heavily.
• Repetitive automation: let AI handle it solo.

Advice to my 2023 self

• Don’t expect magic. Treat AI like a super-fast junior teammate.
• Show with code, not words. DX first, implementation later.
• Validate with temporary tests. They’ll keep you honest during prototyping.
• Don’t keep detail tests forever. They’ll haunt your maintenance.
• Adapt your approach. Context decides the technique.

Final thoughts

Coding without AI now feels like stone tools. Not because AI does it all, but because it gives me speed and breadth.

Looking back, my biggest mistake wasn’t the frustration. It was the resistance. It was thinking “not useful” was a permanent verdict.

Here’s the truth:

• AI won’t replace your job.
• But professionals who use it will replace those who don’t.
• Mastering these tools means delivering more, faster, and with more impact.

If I could tell 2023-me one thing, it’d be this: Don’t fight the tide of innovation. It won’t stop. Resistance only wastes time.