We Know. We’re Just Not Saying It.

I've been working with AI since 2015, not building the models, but sitting in the middle: between the technology and the people using it, and between AI tools and the engineering teams I work with. Back in 2020, I wrote about what that looked like, the resistance, the setbacks, the gap between what AI promised and what it delivered.

Six years later, I want to close the loop. And open a new one.

Most developers that use AI tools every day, getting real results, say very little about it. Not in standups, not on LinkedIn, not even to their closest colleagues. Some worry it makes them look lazy. Some aren't sure what it means for their future.

I've been thinking about why that silence exists, and what it's costing us.

The Honest Reckoning

Engineers are smart enough to see what's happening. We're building tools that will change what this job looks like. Some tasks we do today will be fully automated in a few years. That's not speculation, it's already beginning.

The denial isn't coming from ignorance. It's coming from something that looks more like grief. Because change, even good change, involves loss. The craft of writing a certain kind of code, the satisfaction of solving a certain kind of problem, some of that will move.

But engineers have always built things that make previous work obsolete. That's the job. We automate, and then we move to harder problems.

What's left after automation is the part that requires judgment, ownership, and real understanding of what you're building and why. For some areas, the blast radius of getting it wrong is too large, and the contextual judgment required is too deep. Those fields will need a human hand for longer, and for good reason.

That's not a lesser job. It might be a better one.

Closing the Loop on 2020

In my 2020 article, I wrote that AI would eventually become like computers, not a specialist tool, but something every job simply assumes you know. I also wrote about the resistance I kept encountering: people afraid of it, dismissing it, misunderstanding it.

That resistance hasn't gone away. It's just wearing different clothes.

Back then, the fear belonged to recruiters worried AI would make biased hiring decisions. Today, it belongs to engineers worried that talking openly about AI makes them look replaceable. Both fears are really about the same thing: losing your identity in relation to a tool that feels threatening.

What I said in 2020 still holds: AI handles the mindless work and frees you for the human parts. What's changed is the scale. And that's precisely why the human parts matter more, not less.

(The original article is here if you want the full picture.)

What I Actually Put Together - The technical aspects

Over the last few weeks I went deep. First reading about it, taking courses, then actually building with it, breaking it, supervising it, and learning where it earns trust and where it doesn't.

Here's the pipeline:

A product manager writes a high-level brief. Before anything else, the agent reads context: company documentation, past decisions, meeting notes, presentations. At every stage it works from that foundation, not as a generic AI but as one that understands the product, the team, and where the company is heading. From there it generates the technical design: how it should be built, what needs to be tested, what edge cases to consider.

Then the same agent picks up a task from the backlog, writes the code, and opens a pull request on GitHub. Before that PR goes anywhere, it switches to a review skill, goes through its own code, flags issues, and does up to three rounds of self-correction. Humans review at every gate. The work between gates is almost entirely automated.

When a human approves, the rest takes care of itself: tests run, code merges, deployment happens.

Claude also did this.

I used Claude Code for the heavy lifting, Copilot CLI for command-line workflows, and GitHub's API for version control. The agents connect to external tools through MCP (Model Context Protocol), which lets them act on real systems rather than just generate text.

What I Learned

It works. And it needs watching.

Every meaningful output required real judgment, mine. Knowing when the agent was heading in the wrong direction. Knowing when the self-review missed something. Knowing when the output looked right but wasn't.

That gap, between AI output and quality output, is still a human responsibility. I don't think it stays that way forever. My honest estimate is two years before the supervision burden drops significantly. But we're not there yet.

What surprised me was what that gap is actually made of. It's not about knowing syntax or memorising frameworks. It's about understanding the problem clearly enough to know when the solution is wrong, having the taste, experience, and context to supervise well.

Those aren't automatable skills. They're the core of the job.

Why the Silence Needs to End

The developers building real judgment about when to trust AI output and when to override it are developing something genuinely valuable. But if they don't talk about it, that knowledge stays invisible.

Decisions about how to use these tools in teams, in products, in hiring are being made anyway. And they're better decisions when practitioners are in the room, people who can speak from experience, not just from what they've read.

The conversation is already happening. The only question is who's in it.

I'm still learning. I have more questions than answers. But I'd rather be asking them out loud than pretending they don't exist.

If you're a developer who uses AI daily but hasn't talked about it, I'm genuinely curious what's holding you back.

If you're a non-technical leader figuring out what this means for your teams, find the engineers who are actually using these tools and ask them what they're seeing. That's where the real signal is.

Artur Teixeira, Lead Software Engineer. Working with AI since 2015 as an engineer, not an ML researcher. I write about AI-enabled engineering, developer productivity, and intelligent automation.

Written with AI assistance, after 32 prompts, which is either a testament to human judgment or a warning about trusting AI output. Probably both.