The Hidden Costs We're Ignoring

Every LLM query burns energy equivalent to thousands of Google searches. My MVP development has probably consumed more electricity than a junior developer would use in months, and that energy would be used for a decent human live and not just be burned. We're externalizing environmental costs to investors and cloud providers while pretending this is "efficient" development.

But the energy consumption is just the visible symptom of a deeper problem.

The Training Pipeline Is Broken

LLMs have already processed virtually all public code repositories, Stack Overflow answers, and technical documentation. The well of high-quality training data is running dry.

What happens next? Models will increasingly train on LLM-generated code.

This creates a feedback loop of declining quality. Today's 40% error rate becomes tomorrow's baseline. The subtle bugs and questionable patterns that LLMs generate today become the "best practices" that future models learn from.

We're witnessing the beginning of model collapse in real time.

The Mentorship Crisis

Every hour I spend prompting an LLM is an hour I'm not mentoring a junior developer. Every feature built by artificial intelligence is a learning opportunity denied to a human being.

After twenty years of leadership, I know that senior developers don't emerge from bootcamps or university programs. They develop through:

• Debugging complex production issues with experienced guidance

• Making architectural mistakes and learning from the consequences

• Pair programming with people who've solved similar problems before

• Code reviews that teach judgment, not just syntax

None of this happens when LLMs write the code.

Where Will Future Seniors Come From?

If we replace junior developers with LLMs now, who becomes our senior developers in five years?

The current generation of experienced engineers learned by writing bad code, getting feedback, and gradually developing intuition about software systems. We learned through apprenticeship disguised as entry-level positions.

LLMs break this pipeline. They provide solutions without teaching the reasoning behind those solutions. They generate code without building the problem-solving skills that make developers valuable beyond their ability to produce syntax.

The Real Value of Junior Developers

Junior developers don't just write code – they ask the questions that senior developers have stopped asking:

• "Why does this business rule exist?"

• "What happens if this assumption changes?"

• "Is this pattern actually necessary, or just historical accident?"

These questions force you to articulate business logic, challenge established patterns, and document implicit knowledge. The teaching process clarifies your own thinking – and (best cases) prompts you to document it.

LLMs never really challenge your assumptions. They just implement whatever you specify, regardless of whether it makes sense.

The False Promise of AGI

The industry narrative suggests that current limitations are temporary – that AGI is just around the corner, that reasoning capabilities are emerging, that models will soon match human judgment. This is wishful thinking backed by venture capital, not technical evidence.

True reasoning capabilities require understanding causation, not just correlation. They require the ability to generalize beyond training data, to handle novel situations, to balance competing objectives with incomplete information.

These capabilities aren't emerging from larger language models. They're fundamentally different problems that may require entirely different approaches.

What We Should Do Instead

The solution isn't to abandon LLMs entirely, but to use them appropriately while investing in human development:

Use LLMs for infrastructure and boilerplate – the undifferentiated heavy lifting that doesn't teach valuable skills anyway, while frameworks and better tooling should be solving this, while they don't.

Hire junior developers for feature development – especially the domain-specific logic that requires understanding business requirements and user needs.

Be more explicit about requirements – the discipline that LLMs force us to develop benefits human developers even more.

Focus mentorship on business problem-solving – teach juniors to discuss user value, market fit, and strategic technical decisions rather than just implementation patterns - and also to ask tricky questions.

The Teaching Opportunity

The explicitness that LLMs require – clear specifications, documented patterns, articulated business logic – creates better teaching materials for human developers.

Instead of informal knowledge transfer through osmosis, we can provide structured learning paths with clear examples and comprehensive documentation.

The documentation infrastructure required for effective LLM collaboration is exactly the infrastructure that helps junior developers become senior developers faster.

The Responsibility We Owe

As experienced engineers, we have a responsibility to train the next generation. That responsibility extends beyond individual companies to the entire industry. If we optimize for short-term convenience at the expense of long-term capability development, we're mortgaging the future of software engineering.

The climate costs are real. The model degradation is inevitable. The mentorship gap is growing.

The Choice

We can continue externalizing costs – environmental, educational, and strategic – to pursue the convenience of LLM-generated code. Or we can invest in sustainable approaches: hiring humans, building knowledge, creating systems that improve over time rather than degrade.

The technology will plateau. The energy costs will compound. The knowledge transfer gap will widen.

But junior developers will still become senior developers, if we give them the opportunity.

The choice is ours. For now.