Over the past few months I’ve noticed an interesting divide emerging in engineering teams. It often surfaces during conversations about AI-assisted development tools like Copilot, ChatGPT, Claude, or internal LLM systems.
You can roughly split engineers into two camps.
1. AI Evangelists
These engineers lean heavily into AI tools. They use AI to:
- generate code
- refactor code
- explore unfamiliar codebases
- generate tests
- summarize documentation
- accelerate debugging
Their mindset is simple:
If a machine can accelerate a task safely, use it.
To them, AI is similar to previous productivity leaps: IDEs, stack overflow, compilers, linters, CI pipelines.
2. Native Coders
The second group I call native coders.
This group believes that writing code by hand is a critical part of engineering. Their argument usually goes something like:
- If you don’t write the code yourself, you won’t understand it.
- AI-generated code is sloppy.
- Engineers relying on AI will lose core programming skills.
At its extreme, the sentiment becomes:
“If you didn’t code it by hand, you’re not really programming.”
This mindset reminds me of earlier technology transitions.
We’ve Seen This Before
There are strong historical parallels:
| Old Debate | New Debate |
|---|---|
| Typewriters vs Word Processors | Hand coding vs AI-assisted coding |
| Assembly vs High-Level Languages | Manual coding vs LLM coding |
| CLI vs IDEs | IDE vs AI coding agents |
| Books vs Search Engines | Documentation vs AI summarization |
Every generation believes the previous tools were the “correct” way to do things.
But progress almost always favors higher-level abstractions.
Engineers stopped writing assembly for everything.
Engineers stopped writing memory management manually.
Engineers stopped writing HTML without frameworks.
AI is simply the next abstraction layer.
The Myth: “Handwritten Code Is Better”
One assumption I hear frequently is this:
Engineers who write everything manually produce better code.
I don’t believe this is true.
In fact, I think the opposite can often be true.
Handwritten code frequently suffers from:
- inconsistent patterns
- missing error handling
- poor test coverage
- undocumented logic
- security oversights
AI-assisted workflows can actually improve many of these issues when used correctly.
For example, AI can help engineers:
- generate secure patterns
- add validation
- scaffold tests
- identify edge cases
- summarize complex logic
- detect insecure implementations
Does this mean AI-generated code is perfect?
Of course not.
But the assumption that manual code is automatically superior is naive.
The Real Skill Is Changing
The core engineering skill is shifting.
It’s moving from:
“Can you write code from scratch?”
to
“Can you design systems and guide tools effectively?”
Future engineering excellence will likely emphasize:
- system design
- architecture decisions
- security thinking
- prompt engineering
- debugging AI-generated outputs
- validating correctness
- reviewing code critically
In other words:
Engineers will spend less time typing code and more time thinking about systems.
Understanding the Codebase Still Matters
One concern from the “native coder” side is valid.
Engineers must understand the codebase they are modifying.
AI does not eliminate that responsibility.
But AI can actually help engineers understand codebases faster by:
- summarizing repositories
- tracing dependencies
- explaining unfamiliar modules
- generating architectural diagrams
- identifying entry points
In large organizations where documentation is often outdated, AI can become a powerful codebase exploration tool.
Sometimes AI explanations are more accurate than old documentation.
The Tuition Analogy
This debate reminds me of something else.
The conversation about free tuition.
People who paid their own tuition sometimes argue that future students should also pay.
Why?
Because they had to go through the struggle.
But the logical response is:
If the previous generation had to do it the hard way, shouldn’t we make it easier for the next generation?
The same applies to engineering.
If new tools allow engineers to:
- build faster
- reduce boilerplate
- improve security
- ship more features
Why would we reject that progress?
What Actually Matters
The real priorities for engineering teams should be:
- strong code review
- good architecture
- automated testing
- security awareness
- maintainability
- clear ownership
Whether code was typed manually or generated with AI is far less important than whether it is correct, secure, and maintainable.
The Engineers Who Will Win
The engineers who will thrive in the next decade will likely be those who combine:
- strong foundational knowledge
- curiosity
- AI tooling fluency
- system-level thinking
Not those who insist on doing everything manually.
The future engineer won’t be the person who writes the most lines of code.
It will be the person who can build the most effective systems.