AI Agents and Pair Programming: Why They Work for Some Developers and Fail for Others

🍝 Before the Gen AI Age: Why Some Developers Succeeded and Others Failed

A lot of developers and companies would give up on projects, rewrite them multiple times, never get results, or live a nightmare maintaining software where every change caused bugs.

Why did that happen? Look at these scenarios.

Because they either over engineered or wrote spaghetti code.

🛠️ Before the Gen AI Age: How Developers Made Maintainable Projects

They followed good engineering practices:

Small classes following SRP, and SOLID in general
Small methods following Clean Code
Readable names for methods, variables and table columns
Strongly typed variables
No repeated code
Summaries and comments that really give context instead of stating the obvious
Simple implementations coming from a KISS mindset
A "run tests" button right next to the method in the IDE, so you knew immediately if something broke after a change
Ubiquitous Language from DDD, keeping terminology consistent across every layer of the project, and with business people too
Concise, clear documentation that is actually explained
E2E tests for the UI
Unit tests for the domain
Testcontainers for repositories
YAGNI
A well designed domain layer, with tough business rules properly explained and coded and unit tested
Data access separated with the repository pattern, which also makes testing easier

The real challenge in software is changing and maintaining it in the long term. We contribute to systems that may live for 20 years or more.

🤖 Now the new spaghetti is vibe coding

Let's relate that pre agent experience with the AI agents era, tools like Codex and Claude.

Fabio Akita said something I really liked:

"AI will reveal who you are."

What does that mean?

If your mentality was always:

"Just make it work and move on."

Without caring about code structure, readability, database design, user experience, testing or maintainability, AI will amplify that 10x.

But if you truly believe in good practices, then AI becomes a multiplier in the right direction.

You:

✅ Write .md files with your standards
✅ Learn prompt engineering
✅ Provide context and point agents to documentation
✅ Use planning mode
✅ Analyze the generated code instead of blindly accepting it
✅ Keep iterating prompts to refactor code
✅ Keep pull request review, Git flow and testing culture
✅ Make sure the AI follows your code structure, including terminology and system design
✅ Bring QA professionals in to test

Then the quality stays the same but only much faster.

I built this project with AI agents and I realized something: everything I believe is right was applied in it.

💸 Why are companies hiring junior developers again and failing with AI?

Because spaghetti coded systems lack clear boundaries, correct terminology, test coverage and good documentation.

💡 And if the codebase is confusing for us, it is confusing for the agent too.
It will keep trying and failing until you run out of tokens.

Last year I did an interview and the tech lead asked me:

"How capable are you of working on a very complex project where a single class can have 6 thousand lines or more?"

Then he wanted to know if I had strategies to save tokens, and he told me AI agents were lame because they don't work well.

The first thought that came to my mind was:

"6 thousand lines in a single class? Then those guys don't follow the most basic software engineering principle, Single Responsibility. They probably don't follow anything at all. That's why they have a token problem. The agent keeps iterating to fix errors, but there is no clear logic in their code to begin with."

⚙️ How I'm getting good results with AI agents while keeping my good practices

I write a few .md files, for example:

📄 CLAUDE.md or copilot-instructions.md. Sets the general engineering instructions, and tells the agent which other .md files it has to read.
💬 Communication.md. Instructions for communication, such as not making messages too complicated and sticking to bullet points and concise language.
🏗️ Architecture.md. Defines the high level structure, for example the test strategy with Cypress.
🧩 SystemDesign.md. Defines design patterns and principles such as SRP, Clean Code and DRY.
🚫 Limits.md. Defines restrictions, such as never deleting Azure resources or pushing to master.
📌 Stories/FeatureX.md. One file per feature, where I specify all the requirements and context, so I avoid pasting a massive wall of text into the prompt.

Then my workflow is:

I use plan mode with context the correct effort and model to make sure the generated code follows guidelines.
I do everything in a local environment, on a branch for that feature or change and it will be tested locally a lot before PR.
After accepting the changes, I run the tests, test manually, review, and open the pull request.

Extra personal tips:

🎯 Use the best model for the task. For example Opus for complex work and Sonnet for simpler work.
🧠 Learn your tool of choice. Mine is Claude, so I use /effort for critical tasks, /clear between tasks, /compact on long sessions, and plan mode to discuss before coding.
🔁 Have a backup tool. I also keep Copilot.
📝 For high level planning use ChatGPT Pro. It's much better for writing .md files for spec driven development.
🧠 Use combinations of some aspects of Spec Driven Development at least some .md files in this strategy with strong review process.
🎯Check your usage, I was doing doing generical prompts and Claude Code because of that was making sub agents to search codebase, after I made precise prompts I reduced my usage in around 38%

🏁 Final conclusion

I agree with Fabio Akita. AI will amplify us depending on who we are.

The companies winning with AI are usually the ones that already had maturity, keeping good practices and QA processes.

What we do is organize instructions for machines intelligently. It doesn't matter if the language is assembly or English.