Workflow

How I Use AI in My Development Workflow

Sep 1, 20266 MIN

I didn't know shit about programming when I started college.

I wasn't really a techy person either. I didn't grow dreaming about becoming a software engineer. Honestly, I barely knew what the hell I was getting myself into.

When it was time to choose a program, I had a few options in front of me, and IT was just one of them.

I didn't think about it.

I just signed some paper.

"Yeah, fuck it."

And then things started happening

I think it was around July. I'm not even sure anymore. It's been a while, and I definitely wasn't keeping track of dates back then.

What I do remember is that college hadn't even properly started yet, and suddenly, classes were suspended because of the rain.

So there I was, at home, bored as hell with nothing to do.

I don't really remember what made me start looking into programming.

I just thought:

"Well, I guess I could try learning something before classes start."

So I opened my PC and started looking into web development.

HTML.

CSS.

JavaScript.

Just the basics.

I didn't really know what I was doing. I was following tutorials, copying things, changing things, breaking things, and then spending way too much time trying to figure out why the thing I just changed completely fucked everything up.

But somehow, I got hooked.

There's this stupid little dopamine hit you get when you write some code and actually see it work.

You change something.

Refresh the browser.

And suddenly there's your output.

"Wait."

"I made this shit?"

That feeling got me.

Eventually, I started asking my brother for help.

He's also a software engineer, so I thought:

"Perfect. I have someone I can ask whenever I'm stuck."

Except he didn't really teach me shit. (He's an idgaf kind of guy)

Not because he didn't want to help, but because I was asking questions that were way too basic for someone already working in the industry.

I'd hear things like:

React.

JSX.

Virtual DOM.

Components.

State.

Props.

And I'd just sit there thinking:

"What the fuck is React?"

"What's JSX?"

"Why the hell do we need a Virtual DOM?"

I was completely lost.

So I started figuring things out myself.

Back then, my go-to places were Stack Overflow and the documentation.

I'd search for a problem, open ten tabs, try something, break something else, close three tabs, reopen two of them, and then go back to searching.

Basically, the usual programming experience.

ChatGPT was already around too, and I did use it from time to time.

But the AI-generated code back then was...

Pretty shit.

It could generate a lot of code, but that didn't mean the code was good.

Sometimes I'd ask for something simple and get a whole fucking architecture for it.

There would be abstractions I didn't need, code I didn't understand, and solutions that felt like they were written just to make the problem go away.

I'd ask:

"How do I do this one simple thing?"

And it'd basically respond:

"Great question. Let's redesign your entire fucking application."

So I never really became a big fan of AI-generated code.

I remember laughing when people started saying AI was going to replace programmers.

"There's no fucking way."

At that point, tools like GitHub Copilot were useful, but mostly for code completion.

It could finish a line or suggest the next few lines, and that was pretty cool, but I didn't see it changing how we actually developed software.

Fast forward to 2026

A lot had changed.

AI wasn't just autocomplete anymore.

Claude Code was becoming one of the biggest things people were talking about in the developer space.

Everywhere I looked, developers were talking about agents, context, AI-assisted development, and how they were using AI to build things differently.

And honestly, I was still skeptical.

Actually, skeptical is probably putting it nicely.

I was making fun of people who were using it.

I thought a lot of it was overhyped.

I'd already seen AI generate a bunch of useless code before, so I didn't really understand why I should suddenly trust it with more of my development work.

Looking back, I was probably a little arrogant about it.

Maybe a lot.

Then things started getting a little more serious.

There were a lot of layoffs happening across the tech industry.

And this time, it wasn't just something I was reading about online.

I started seeing changes closer to me too.

Our lead senior engineer left the company after getting a new position at a much bigger tech company.

What caught my attention was his new role.

He was going to be working as an AI-assisted software engineer.

When he left, some of the responsibilities he was handling were passed on to me.

And that's when I started feeling the pressure.

I suddenly had more responsibility, and at the same time, it felt like the entire industry was moving toward AI.

AI this.

AI that.

AI is replacing developers.

AI is making developers 10x more productive.

AI agents.

Context engineering.

Loop engineering.

Claude Code.

I was hearing about it constantly.

And honestly, it started getting exhausting.

So I finally thought:

"Fuck it."

"Let me actually try this."

I think it was around late March when I bought an AI subscription and decided that I was going to properly learn how these tools worked.

Not just asking AI to write some code and copy-pasting whatever it gave me.

I wanted to understand why people were getting so much more out of these tools than I was.

That's when I started going down the hole.

And fuuuuckkkk, there was a lot to learn.

My first serious attempt at AI-assisted development

The whole idea of loop engineering started making more sense to me.

The idea was basically to let the AI work through a problem, review what it did, make changes, run things again, and keep going until it reached a reasonable result.

It was actually pretty solid.

For the first time, it actually felt like I wasn't just asking AI for snippets (ngl Opus literally cooked the architecture)..

I was giving it a problem and letting it work through the problem with me.

But there was one problem.

It was expensive.

At least for me.

I was paying for an AI subscription, and the way I was using it meant I was burning through my usage pretty quickly.

Every time I wanted the model to keep going, review something, make changes, run through another iteration, and then do it all over again, I could practically feel my wallet

At some point I just thought:

"Fuck this."

So I started looking for another way.

That's when I started getting really interested in context engineering.

Instead of constantly asking the model to figure everything out through multiple loops, I started thinking more about what information I could give it upfront.

What does it actually need to know?

What files should it see?

What are the rules of our project?

What conventions do we follow?

What should it never do?

What does our architecture look like?

What does the business logic look like?

The more useful context I could provide, the less time the model had to spend guessing.

And honestly, that changed the way I thought about AI.

The problem wasn't always that the model wasn't smart enough.

Sometimes I just wasn't giving it enough fucking information.

And this was also around the time I started getting more involved in the lead side of my role.(Gonna let myself have this one 😏)

I wasn't just thinking about how I could use AI to make myself faster anymore.

I started thinking about how the entire development team could use it.

The AI developer cycle

I proposed an approach I called the “Agentic Development Cycle.”

The idea was pretty simple.

Instead of treating AI as a tool developers occasionally opened when they got stuck, we would actually build it into the development process.

AI would be involved throughout the cycle.

Planning.

Implementation.

Code review.

Testing.

Documentation.

And eventually, even parts of our CI/CD workflow.

We started experimenting with different ways of integrating AI into the process.

I used it to review pull requests, generate and improve test scripts, help write tests, and eventually even integrate parts of our CI/CD pipeline with MCPs.

And it worked.

Actually, it worked really fucking well.

We became much more productive.

Things that used to take hours could sometimes be done in minutes.

Code reviews became faster.

Writing tests became less of a chore.

I could give an AI agent the right context and let it go through a task that would normally require a developer to spend a good chunk of their day doing.

At some point, I realized something that I didn't really know how to feel about.

We were becoming extremely productive.(like legit)

And then people started getting laid off.

About half of our developers were eventually let go.

And I remember thinking:

"Shitt."

"Is this my fault?"

That question stayed with me.

Because I was one of the people pushing for this.

I was the one saying we should integrate AI more deeply into our development cycle.

I was the one showing the team how we could use these tools.

I was the one experimenting with ways to automate parts of our workflow.

And now I was watching the consequences of that productivity.

It was around June when it really started to sink in.

Something didn't feel right.

On paper, what we had built was a success.

We were shipping faster.

We were getting more done.

We had better tooling.

We were automating things that used to take a lot of manual effort.

From a purely engineering perspective, it was fucking impressive.

But software development isn't just about output.

There are people behind that output.

And suddenly I couldn't stop thinking about the people who were no longer there.

I started questioning whether I had pushed AI too far.

Was I helping the team become better engineers?

Or was I helping the company realize it needed fewer engineers?

Those are two very different things.

What changed for me

Before all of this, I thought the biggest question was:

"Can AI write good code?"

Then I started asking a different question:

"What happens when AI can write enough good code that the way we build software has to change?"

And that question is much harder to answer.

Because once you see how productive these tools can make a small team, it's difficult to unsee it.

But there's another side to that productivity that I didn't really expect.

AI can make you faster, but it can also make you juggle way more shit at once.

You're reviewing pull requests, managing AI agents, jumping between different tasks, checking what the AI changed, fixing things it got wrong, keeping track of context across multiple conversations, and still trying to actually think about the problem you're solving.

At some point, I started wondering if I was really saving time or just moving the work around.

The bottleneck wasn't always writing the code anymore.

Sometimes it was keeping up with everything happening around the code.

And that can be exhausting.

The irony is that AI can reduce the amount of time you spend typing code while increasing the amount of context you have to hold in your head.

That's probably the part of AI that I didn't expect.

I started using AI because I wanted to become a faster developer.

Instead, I ended up questioning not just how I develop software, but what being a developer even means when the tools become this capable.

So, how do I use AI now?

After everything that happened, I don't think about AI the same way anymore.

I don't use it because I want to stop writing code.

I use it because there are parts of development where I simply don't need to spend my time doing everything manually anymore.

But I also learned that throwing AI into a development workflow isn't enough.

The way you use it matters.

Today, I try to give AI as much useful context as possible before asking it to do anything.

I want it to understand the project, the architecture, the conventions, and the problem I'm actually trying to solve.

I use it when I'm exploring an unfamiliar codebase.

I use it to understand concepts.

I use it to review my code and pull requests.

I use it to write and improve tests.

I use it for repetitive tasks and scripts.

I use it when I'm debugging something that would otherwise take me an hour of searching through documentation and Stack Overflow.

I've also started integrating AI deeper into the development process itself.

MCPs.

CI/CD.

Code reviews.

Testing.

Documentation.

Other parts of the workflow.

There's a lot that can be automated or assisted.

But there's one thing I don't want to lose in all of this:

I still need to understand what the fuck is going on.

That's probably the biggest lesson I've learned.

When I first started using AI, I thought the goal was to get it to generate better code.

Now I think the goal is to give it enough context and direction that it can actually help me think through a problem.

There's a huge difference between:

"Build this feature."

and:

"Here's our architecture, here's how this part of the system works, here's the business rule, here's what we already tried, and here's what I need to accomplish.

Help me figure out the best way to approach this."

The second one isn't about asking AI to replace the developer.

It's about giving the developer another brain to work with.

And yeah, sometimes that brain is still confidently full of shit.

So I still review the code.

I still test things.

I still question the answer.

Because at the end of the day, AI doesn't take responsibility for what gets shipped.

I do.

Final thoughts

Looking back, it's kind of funny.

I started without even knowing what programming was.

Now I'm a Lead Engineer, working with AI every day and helping integrate it into how our team builds software.

I'm also working as an AI Engineer on the side, building and experimenting with AI myself.

I don't think AI replaced me.

It changed me.

And honestly, I think we're still figuring out what that means.

For now, this is how I use AI.