avelarder

🤖 Facebook: 70% of our code is AI-generated. The question isn’t IF we’ll reach 100% – it’s WHEN. And what happens to developers then?

Are we coding ourselves out of existence? 👇

When Facebook announced that 70% of their code is now AI-generated, it sparked conversations about developer responsibility and code quality. But lurking beneath these discussions is a more existential question: what happens when we reach 100%?

The Paradox of Progress

Currently, we tell developers they’re still responsible for AI-generated code. They must review it, understand it, test it, and take ownership of what ships. This makes sense at 70% AI generation – there’s still substantial human involvement in the process.

But this logic contains a fundamental contradiction. If AI can generate 70% of code reliably, why can’t it generate 100%? And if it can generate 100%, why would it need human oversight?

What True 100% AI Code Generation Really Means

Here’s the uncomfortable truth: reaching 100% AI-generated code doesn’t just mean AI writes more lines of code. It means AI has achieved something far more profound.

True 100% AI code generation requires AI to:

Understand complex business requirements and translate them into technical solutions
Make sophisticated architectural decisions across multiple systems
Perform comprehensive code review and quality assurance
Handle debugging, optimization, and performance tuning
Manage security considerations and compliance requirements
Adapt dynamically to changing requirements and edge cases
Integrate seamlessly with existing systems and legacy code

At this point, we’re not talking about a sophisticated autocomplete tool. We’re talking about artificial general intelligence that can perform every cognitive aspect of software development.

The Evolution of Extinction

The progression from today’s AI tools to true autonomous development follows a predictable pattern:

Phase 1: AI as Assistant (Current State)

Developers use AI to generate code snippets and boilerplate
Humans remain essential for architecture, review, and decision-making
Responsibility clearly lies with human developers

Phase 2: AI as Collaborator (Near Future)

AI handles larger portions of the development lifecycle
Humans focus on high-level design and quality assurance
Shared responsibility between human oversight and AI capability

Phase 3: AI as Replacement (The 100% Question)

AI manages entire development cycles independently
Human involvement becomes minimal or ceremonial
Traditional developer roles become largely obsolete

The Historical Precedent

This isn’t unprecedented. Technology has eliminated entire professions before:

Human computers were replaced by electronic calculators and computers
Typing pools disappeared when word processors became accessible
Map makers became largely obsolete with GPS technology
Factory workers were replaced by automated manufacturing

In each case, the technology didn’t just augment human capability – it eventually surpassed it entirely.

The New Reality: What Replaces Developers?

If AI achieves true autonomous development capability, entirely new roles might emerge:

AI System Managers: Professionals who configure, monitor, and maintain AI development systems across organizations.

Business-to-AI Translators: Specialists who can effectively communicate business needs to AI systems and validate that the resulting software meets those needs.

Compliance and Ethics Officers: As AI systems make more autonomous decisions, human oversight for regulatory compliance and ethical considerations becomes crucial.

Integration Architects: Experts who design how AI-generated systems interact with existing infrastructure and legacy systems.

But here’s the critical question: will these new roles require as many people as traditional software development? History suggests probably not.

The Timeline Question

The transition to 100% AI code generation hinges on several technological breakthroughs:

Advanced reasoning capabilities: AI must understand not just syntax, but complex business logic and system interactions
Autonomous testing and validation: AI must be able to verify its own work comprehensively
Dynamic adaptation: AI must handle changing requirements and unexpected edge cases
System-wide architecture: AI must think holistically about complex, multi-system environments

Some experts predict this could happen within 5-10 years. Others believe it’s decades away. But the direction is clear, and the pace is accelerating.

The Uncomfortable Conclusion

Software development might be one of the first knowledge work domains to face potential full automation, precisely because code is already a formal, logical language that AI can manipulate effectively.

We’re in a unique position: we’re building the very technology that might replace us. Every improvement we make to AI development tools brings us closer to our own professional obsolescence.

The real question isn’t whether this will happen, but how we prepare for it.

Some developers might transition to AI management roles. Others might move to fields that remain fundamentally human-centric. Many might need to completely reinvent their careers.

What This Means Today

For current developers, this reality demands serious strategic thinking:

Develop AI-resistant skills: Focus on areas that require human judgment, creativity, and interpersonal interaction
Become AI-native: Learn to work effectively with AI tools now, while there’s still time to shape how they’re used
Think beyond coding: Develop skills in business analysis, product management, or other domains that complement technical knowledge
Stay adaptable: The pace of change means flexibility and continuous learning are more valuable than deep specialization

The Final Question

As we stand at 70% AI-generated code and march toward 100%, we face a profound question: Are we building tools to augment human capability, or are we coding ourselves out of existence?

The answer may depend on how quickly we can adapt to a world where the most valuable skill isn’t writing code – it’s knowing what code should accomplish and why it matters.

The future belongs not to those who can code, but to those who can think, adapt, and find meaning in a world where machines handle the implementation details.

The 100% question isn’t just about code generation. It’s about the future of human work itself.

I think it is very convenient the use of the ForEach statement when we want to loop through a list of items in C#. Simple and concise, easy to read but what is going on behind the scenes? Is the best option? This article will explore each option in detail.

Let’s start:

The old fashioned FOR loop

The for statement executes a statement or a block of statements while a specified Boolean expression evaluates to true. We just need to define a starting point and an increment pattern of the variable used as index.

        public void ForLoop()
        {
            sum = 0;
            for (int i = 0; i < elements.Count; i++)
            {
                sum += elements[i];
            }
        }

The compiler translates/refactors high-level language constructs to lower-level language constructs. This is important to understand as it could compromise the performance of your code. All these transformations happen before your code is compiled into IL, this step is called Lowering.

After lowering, the code would look like this:

    public void ForLoop()
    {
        sum = 0;
        int num = 0;
        while (num < elements.Count)
        {
            sum += elements[num];
            num++;
        }
    }

Ok, that’s interesting! The for statement has been replaced by while.

The cool kid, ForEach.

The foreach statement executes a statement or a block of statements for each element in an instance of the type that implements the System.Collections.IEnumerable or System.Collections.Generic.IEnumerable<T> interface.

        public void ForEachLoop()
        {
            sum = 0;
            foreach (var element in elements)
            {
                sum += element;
            }
        }

Without a doubt, this option is easier to read and understand as there is no need of indexes and increment patterns. After lowering, the code looks as follows:

    public void ForEachLoop()
    {
        sum = 0;
        List<int>.Enumerator enumerator = elements.GetEnumerator();
        try
        {
            while (enumerator.MoveNext())
            {
                int current = enumerator.Current;
                sum += current;
            }
        }
        finally
        {
            ((IDisposable)enumerator).Dispose();
        }
    }

OK.. there’s some magic here, the code now includes try/finally in order to dispose the enumerator. However, the while statement remains the same, compared with the previous example.

Even fancier, List.ForEach

This option only applies to collections of type List allowing to execute an action for each element of the list, see more.

        public void ForEachLambdaLoop()
        {
            sum = 0;
            elements.ForEach(
                x => sum += x
            );
        }

Looks nice to be honest, the method is expecting an Action that will be executed for each element in the collection. After lowering this code, this is how it looks like:

    public void ForEachLambdaLoop()
    {
        sum = 0;
        elements.ForEach(new Action<int>(<ForEachLambdaLoop>b__5_0));
    }

    [CompilerGenerated]
    private void <ForEachLambdaLoop>b__5_0(int x)
    {
        sum += x;
    }

Note that a new method to compute the arithmetic operation has been added and also decorated with CompilerGenerated.

How to compare all three options?

To get some metrics, I have created a sample project that you can download and use for your reference. In this case, I am using the BenchmarkDotNet package to analyze the code during its execution.

C:\temp\sharplab>dotnet add package BenchmarkDotNet

I have defined a basic class including three methods for each option discussed above. It is important to execute the code in Release mode for Benchmark to work.

C:\temp\sharplab>dotnet run -c release

The results

It is kind of shocking that a for statement executes in less than half of the time of the other two options. By looking at the code, I already knew that it would be the fastest option, but I had no idea how fast!

Summary

Two things to take away from this article:

Understand the process of lowering in C#.
Benchmark your code.

By the way, if someone says that your code is not efficient because you are initializing a List and later, adding each element by calling the .Add() function. They are wrong, it is the same thing after lowering.

Visit: https://sharplab.io/

private readonly List<int> elements;
private int sum = 0;

public Loop()
{
    elements = new List<int>() {1,2,3,4,5,6,7,8,9,10};
}

private readonly List<int> elements;

private int sum = 0;

public Loop()
{
  List<int> list = new List<int>();
  list.Add(1);
  list.Add(2);
  list.Add(3);
  list.Add(4);
  list.Add(5);
  list.Add(6);
  list.Add(7);
  list.Add(8);
  list.Add(9);
  list.Add(10);
  elements = list;
}

Cheers!

Author: avelarder

The 100% Question: What Happens When AI Writes All Our Code?