Jeff Bruchado
Back to blog

DHH: AI Tools Still Do Not Compare to Junior Programmers

Hello HaWkers, David Heinemeier Hansson, better known as DHH, creator of Ruby on Rails and CTO of 37signals (Basecamp/HEY), made a statement that generated much debate in the developer community: according to him, AI programming tools still do not compare to most junior programmers.

In an era where many predict the end of developers, the opinion of one of the most influential names in web development brings a different perspective. Do you agree with DHH?

What DHH Said

The statement was made in a discussion about the current state of AI tools for programming.

The Context of the Statement

Main quote:

"I have been using Copilot, Cursor, Claude, and other AI programming tools extensively. They are useful as assistants, but they are still far from replacing even a competent junior programmer. AI does not understand business context, does not question bad requirements, and does not learn from team culture."

Points raised by DHH:

  1. AI works well for isolated tasks
  2. Fails to understand broad project context
  3. Does not question design decisions
  4. Generated code often needs significant review
  5. Junior developers learn and improve, AI does not evolve in context

Community Reactions

The statement divided opinions:

Agree with DHH:

  • Senior developers with team experience
  • CTOs of companies that hire juniors
  • Programming educators

Disagree:

  • AI enthusiasts and early adopters
  • Solo developers who use AI intensively
  • Startup founders with lean teams

Technical Analysis: AI vs Junior Developer

Let's objectively compare the capabilities of each.

What AI Does Well

1. Boilerplate code generation:

// AI quickly generates:
// - CRUD operations
// - Standard configurations
// - Basic unit tests
// - Function documentation

// Example: Ask AI to create a REST endpoint
// Result is usually functional and correct
app.get('/api/users/:id', async (req, res) => {
  try {
    const user = await User.findById(req.params.id);
    if (!user) {
      return res.status(404).json({ error: 'User not found' });
    }
    res.json(user);
  } catch (error) {
    res.status(500).json({ error: 'Internal server error' });
  }
});

2. Translation between languages:

  • Python to JavaScript
  • SQL to ORM queries
  • Code to pseudocode

3. Refactoring existing code:

  • Apply design patterns
  • Improve readability
  • Extract functions

4. Assisted debugging:

  • Identify obvious errors
  • Suggest fixes
  • Explain stack traces

Where AI Fails

1. Business context:

// AI generates "correct" code but without understanding business:

// Requirement: "Calculate discount for VIP customer"
function calculateDiscount(customer, order) {
  if (customer.isVIP) {
    return order.total * 0.1; // 10% discount
  }
  return 0;
}

// What a junior would ask:
// - What defines a VIP customer?
// - Is the discount always 10% or does it vary?
// - Are there minimum/maximum limits?
// - Does discount stack with promotions?
// - Does it need auditing?
// - How does rollback work?

2. Architectural decisions:

// AI accepts any structure you ask for
// Junior would question:
// - "Why microservices for 3 endpoints?"
// - "Do we really need GraphQL?"
// - "Wouldn't it be better to use the framework's ORM?"

3. Code quality at scale:

// AI generates code that works in isolation
// But creates inconsistencies in large projects:

// File A (generated Monday):
const getUserById = async (id) => { ... }

// File B (generated Wednesday):
async function fetchUser(userId) { ... }

// File C (generated Friday):
const getUser = (id) => User.find(id);

// Three different ways for the same operation
// Junior would learn the team's pattern

The Value of a Junior Programmer

DHH argues that junior developers bring value beyond code.

Contextual Learning

What juniors develop:

  1. Domain knowledge:

    • Understand the business gradually
    • Ask questions that reveal gaps
    • Document tribal knowledge

  2. Team culture:

    • Learn project conventions
    • Absorb best practices from seniors
    • Propagate patterns consistently

  3. Healthy questioning:

    • Challenge the status quo
    • Bring fresh perspectives
    • Identify unnecessary complexity

Talent Pipeline

Economic argument:

Aspect Human Junior AI
Initial cost Higher Lower
Evolution Becomes senior Stagnant
Context Accumulates Loses between sessions
Creativity Positive surprises Predictable
Mentoring Can mentor others Does not transfer knowledge

💡 Insight: Companies that stopped hiring juniors face seniority gaps in 3-5 years.

Non-Technical Skills

What AI does not do:

  • Participate in planning meetings
  • Defend technical decisions
  • Negotiate realistic deadlines
  • Communicate blockers proactively
  • Build relationships in the team

Practical Use Cases

When to use AI vs when to prefer junior developer?

AI Works Better For

1. Short-term solo projects:

// Quick prototype, hackathon, MVP
// AI accelerates significantly

// Scenario: Create landing page in 2 hours
// AI + experienced developer = great result

2. Repetitive tasks:

// Generate 50 similar components
// Convert API v1 to v2
// Add TypeScript types to JS project

// AI does in minutes what would take hours

3. Individual learning:

// Explore new language
// Understand unknown library
// Debug legacy code

// AI as personal tutor is excellent

Junior Works Better For

1. Long-term projects:

// Systems that will last years
// Code that many people will touch
// Products with continuous evolution

// Junior learns and contributes more and more

2. Work that requires context:

// Maintenance of complex systems
// Integration with business processes
// Support for internal clients

// Junior understands the "why" beyond the "how"

3. Team growth:

// Reverse mentoring for seniors
// Living documentation of the project
// Knowledge continuity

// Investment that pays off in the future

The Balanced View

Reality is probably in the middle ground.

The Hybrid Model

How efficient teams use AI:

// Modern workflow:

// 1. Junior receives task
const task = "Implement PDF report export";

// 2. Junior researches and plans with AI help
// - Which libraries to use?
// - Code structure?
// - Edge cases?

// 3. Junior implements with AI assistance
// - AI generates boilerplate
// - Junior adapts to project context
// - Junior adds specific error handling

// 4. Senior reviews
// - Decision validation
// - Educational feedback
// - Merge when approved

// 5. Junior learns and improves
// - Next similar task will be faster
// - Knowledge stays in the team

Productivity Metrics

Recent studies show:

Scenario Gain with AI
Solo dev + AI +40-55%
Junior + AI + mentor +30-40%
Team without AI Baseline
AI only (no human) Not viable for production

💡 Data conclusion: AI amplifies developers, does not replace them.

Implications For Your Career

What does this mean for you as a developer?

If You Are Junior

What to do:

  1. Use AI as a tool, not a crutch:

    • Learn the fundamentals first
    • Understand the code AI generates
    • Question AI suggestions

  2. Develop skills AI does not have:

    • Communication
    • Business understanding
    • Solving ambiguous problems

  3. Document your learning:

    • Show evolution to the team
    • Create shareable knowledge
    • Be indispensable for the context

If You Are Senior

What to do:

  1. Incorporate AI in your workflow:

    • Increase your productivity
    • Focus on high-level decisions
    • Use saved time for mentoring

  2. Continue hiring juniors:

    • Talent pipeline is critical
    • Diversity of perspectives
    • Team sustainability

  3. Teach responsible AI use:

    • When to trust AI
    • When to question
    • How to validate output

If You Are Deciding Career

Is programming still worth it?

Yes, but the profile is changing:

  • Fewer mechanical "coders"
  • More "problem solvers"
  • Value in understanding complex systems
  • Importance of soft skills grows

What the Future Holds

Trends for the coming years.

Likely Evolution

2026-2028:

  • AI improves in project context
  • More integration with team tools
  • Juniors learn to collaborate with AI from the start

2028-2030:

  • AI may maintain context of entire projects
  • But still does not replace human judgment
  • New specializations emerge

DHH's Advice

Summary of position:

"I am not saying AI is useless. I am saying it is a tool, like any other. And like any tool, it works best in the hands of someone who understands what they are doing. A junior who learns to use AI well is more valuable than AI alone."

Conclusion

DHH's statement brings an important perspective amid the hype about AI replacing developers. AI tools are powerful, but they still do not replace the unique qualities that human developers bring: context, questioning, continuous learning, and judgment.

Key points:

  1. AI is excellent for isolated and repetitive tasks
  2. Fails in business context and architectural decisions
  3. Junior developers learn and evolve, AI does not
  4. The hybrid model (human + AI) is more efficient
  5. Investing in juniors is investing in the team's future

The real question is not "AI or humans," but "how to use AI to amplify humans." And for that, we continue to need developers at all levels.

For more on the future of developer careers, read: Job Market For Developers in 2026: The Era of Specialists.

Let's go! 🦅

Comments (0)

This article has no comments yet 😢. Be the first! 🚀🦅

Add comments