I had a draft post sitting in my local repo for a while, where I was about to scream about how AI is overestimated. Well, that post aged pretty badly. I never published it, and looking back at the notes I’m glad I didn’t. So what I’m going to write today will only be about my current workflow and how I actually use AI in my daily work — no hype, no predictions, just what I’ve found useful.

About 15 months ago I left a comfortable senior engineering role at a fintech company to go independent and build software products with AI coding assistants as my primary collaborators. I'm 38, have a mortgage, and my wife was pregnant with our second kid at the time. Not exactly the ideal moment for a career experiment.

I want to share what that experience has actually been like, because there's a lot of hype and doom out there, and not enough honest accounts from people who've spent serious time in the trenches with these tools.

Background

I've been writing software professionally for about 16 years. Mostly backend -- Java, Python, some C++ earlier on. I'm not a 10x developer. I'm a pretty average senior engineer who got tired of sprint planning meetings and wanted to build things on my own terms.

I committed to using AI coding assistants for everything. I rotate between a few different ones depending on the task -- they all have different strengths and keep leapfrogging each other every few months.

What 1,800 hours looks like

I tracked my time carefully because I'm billing myself against savings. Roughly 1,800 hours of active AI-assisted development this year. About 6-7 hours a day, six days a week.

I shipped three products: a multilingual document processing pipeline, a monitoring tool for small SaaS companies, and a real-time audio processing app still in beta.

Two of those required significant Rust and Go code. I had never written production Rust before this year. The AI assistants didn't just help me write unfamiliar languages -- they helped me understand the idioms, memory models, ecosystem tooling. Zero to shipping production Rust in about three months. That would have been 12-18 months solo.

I also went deep on vector embeddings, fine-tuning smaller language models, building custom data pipelines. A year ago I couldn't have explained cosine similarity. Now I have opinions about chunking strategies.

The part nobody talks about

Here's where I push back on the pure optimism narrative.

AI assistants are confident. Relentlessly, dangerously confident. They generate code that looks perfect, passes review, and has a subtle bug that surfaces three weeks later at 2am. I've lost entire days to AI-introduced issues I trusted too quickly.

I fell into what I call "velocity addiction." Moving so fast you skip careful review. You trust the output because it's been right fifteen times. Then time sixteen bites you hard.

One painful incident: an AI-generated database migration looked correct, passed tests, then corrupted two days of user data in staging. The logic error was subtle -- null handling that was technically valid but semantically wrong for my schema. Caught it before production, but it shook me.

These tools also make you feel more competent than you are. I wrote Rust that compiled and ran, but a friend with five years of Rust experience pointed out I was fighting the borrow checker in ways that would break at scale. AI helped me get it working but didn't teach me to think in Rust. There's a difference.

What I believe now

AI coding assistants are genuinely transformative for experienced developers. The key word is experienced. You need enough background to evaluate output, to smell when something's wrong even if it compiles.

The best mental model: you're directing a very talented but very junior team that never sleeps. They produce enormous amounts of work and know trivia about every framework. But they have no judgment. They don't understand your users or your architectural decisions. They will confidently lead you off a cliff if you let them.

The "AI will replace developers" framing is wrong, but not for comforting reasons. It's not that AI can't code -- it clearly can. It's that the hard part of software engineering was never the coding. It's figuring out what to build and why. AI is exceptional at mechanical parts and bad at strategic parts. For now.

The honest numbers

Am I more productive? Yes. Roughly 3-4x in raw output. But my error rate is higher too. I ship faster and fix more bugs. The net is positive, but it's not the clean 10x story that makes good tweets.

Am I making money? Barely. AI made building dramatically easier but didn't help with finding customers at all.

Would I do it again? Without hesitation. This year taught me more than the previous five combined.

Still figuring it out

Some days I feel like I'm living in the future. Other days I'm mass-reverting AI-generated commits at midnight questioning my life choices.

My advice if you're leaning into this: do it, but don't trust it. Build review habits before you build velocity. Keep an honest log of time spent fixing AI-introduced issues -- that number is higher than you think.

Curious to hear from others who've spent serious time with these tools. Where do you draw the line between AI-assisted and AI-dependent?

Three years ago, building a new software project felt like preparing for a mountain climb. You packed tools, planned every step, searched Stack Overflow for rope, and hoped the weather held.

In 2026, it feels more like stepping into a high-speed train.

Same destination. Different speed.

I’ve spent more than four years deep in Python development, building automation systems, data tools, internal products, and experimental AI workflows. I’ve written code the slow way, the painful way, and the “why did I do this manually?” way.

And if I’m honest, AI coding tools changed one thing more than anything else:

They didn’t replace coding. They removed friction.

How I actually use AI in software development today, why context matters more than hype, and why this gets much harder in SAP.

I used AI every day for 30 days as a backend engineer.

Not for side projects or experiments — but in real work: debugging issues, writing code, understanding systems, and reviewing logic.

Some things became 10× faster.
Others actually made me worse.

Here’s what actually changed.

At first, I thought AI would mostly help me write code faster. That’s how it’s usually presented, as a way to speed up implementation or generate code automatically.

But after using it daily for a while, I realized that this is not where it actually brings the most value.

AI doesn’t really change how fast I type code. It changes how I approach problems, especially the parts of the job that are slow, repetitive, or mentally expensive.

The way I think about it today is simple: AI behaves like a very fast junior engineer.

It can generate ideas quickly, suggest implementations, and help explore possibilities. But it doesn’t truly understand the system, the business context, or the consequences of a decision.

Once I started treating it this way, it became much more useful — and much less dangerous.

There is no shortage of AI tools aimed at developers right now: chat assistants, IDE completions, agents that promise to run your tests, and new products every month with overlapping features. I am not going to argue which one is “best.” Instead, here is what I am actually using today on hobby code: ChatGPT for quick, low-context questions, Cursor when the work needs my repository in the loop, and GitHub Copilot for fast inline help while I type. That trio might change, but it reflects how I have learned to spend money and attention in 2026.

The through-line is simple: match the tool to how much context the problem needs. That stops me from dumping half a repo into a browser tab for a vague design question, or firing up an editor assistant when I only wanted a two-paragraph explanation of something I could read in the docs.

This is not a product review. It is a snapshot of how I work, using the projects on my projects page as concrete examples.

I used to think AI would replace developers.
Now I use it every day — and it made me a better engineer.

When I started learning web development, everything felt slow:
• Debugging took hours
• Understanding docs was confusing
• Writing boilerplate was repetitive
• Building backend logic felt complex

Then I started using tools like ChatGPT.
And everything changed.

⚡ Faster debugging
⚡ Clear explanations of complex concepts
⚡ Quick boilerplate generation
⚡ Faster learning of frameworks like Next.js and Node.js

But here’s the reality:

AI didn’t replace my skills.
It amplified them.

Because AI still cannot replace:
• System design thinking
• Backend architecture decisions
• Scalability planning
• Real-world problem solving

Lesson
The future of software development belongs to developers who:
✔ Use AI as a tool
✔ Focus on solving real problems
✔ Build scalable systems

AI is not your competitor.
It’s your productivity partner.

Are you using AI in your development workflow?
Or are you still avoiding it?

#AIForDevelopers #SoftwareEngineering #DeveloperProductivity #WebDevelopment #Programming #FutureOfWork #FullStackDevelop

What's up everyone? Today I wanted to make a quick video since I thought it would be interesting talking about how I currently use AI in my work as a software engineer working for Microsoft in their Azure high performance computing group.

"AI will replace us all."

That's what most posts are saying right now.

But the reality is a bit different.

I use AI daily.

First with Cursor, then with Claude Code.

And I have to say: it gives a real boost for simple tasks.

It's useful for:
1.debugging (classic rubber duck debugging situation)
2.explaining business logic
3.speeding up my workflow — both on the code side and on unit tests

But this works because I know the fundamentals.
Frontend. JavaScript. TypeScript.

Recently, I tried something different:
porting a side project to Go, as a learning exercise.

I also used AI as a learning companion.

Asking it to explain Go concepts, syntax, and patterns I wasn't familiar with.

And here's what I noticed:
AI is strong at converting logic.

It's also decent at explaining things.

But without building the fundamentals myself, could I actually solve the problems that came up?

Not to mention - a lot of the generated code is potentially inefficient.

And without knowing Go, I wouldn't even spot it.

So yes, AI is powerful.

But only if you know the fundamentals of what you're doing.

You can use it to learn faster.

But you still have to do the learning.

Did you experience something similar?