DEV Community: Williams

What Comes After AI-Assisted Programming?

Williams — Tue, 22 Sep 2026 19:59:55 +0000

For the last few years, one of the biggest changes in programming has been the rise of AI coding assistants.

At first, they helped us complete a line of code.

Then they started writing functions.

Then entire files.

Now, AI coding agents can research a problem, create an implementation plan, modify a codebase, run tests, fix errors, and continue working without needing a person to explain every single step.

That makes me wonder:

What comes next?

I don't think the next big change in programming will simply be a better autocomplete tool. I think the way we build software is going to change around AI.

Here are some trends I expect to become much more important.

1. AI agents will become the normal way of building software

The biggest shift is already happening.

Developers are moving from asking AI for individual pieces of code to giving it entire tasks.

That distinction is important.

There is a big difference between saying:

"Write a Python function that does X."

and saying:

"Add this feature to the project, test it, and let me know if anything breaks."

The second request is much closer to delegating work to another developer.

AI coding agents are already becoming common in professional development, and I expect this trend to continue.

The IDE of the future may not primarily be a place where you type code. It may become a place where you direct, inspect, test, and coordinate AI agents that write the code.

2. Writing code will become less important than describing what should be built

This does not mean programming disappears.

It means the abstraction level changes.

For decades, programmers have already worked with abstractions. We stopped writing machine code directly. We moved to higher-level languages, frameworks, libraries, and APIs.

AI could be the next layer.

Instead of thinking about every implementation detail first, developers may increasingly describe the desired behavior, constraints, architecture, and requirements, while AI handles more of the implementation.

In other words, the ability to specify a problem may become almost as important as the ability to implement it.

And that could completely change what we consider a programming skill.

3. Spec-driven development could become much more important

There is a problem with giving AI a vague instruction:

It can produce a lot of code very quickly, even when the original idea was poorly defined.

This is why I think specifications will become more important as AI gets better.

Instead of immediately asking an agent to build something, developers may first define:

What the system should do
What it should not do
Expected inputs and outputs
Security requirements
Performance constraints
Tests and acceptance criteria
How success should be measured

Then the AI gets to work.

This is almost the opposite of the idea that AI means you no longer need to plan.

If anything, better AI may require better planning.

The easier it becomes to generate code, the easier it becomes to generate the wrong code at a much larger scale.

4. Testing and verification will become a major part of AI programming

This might be one of the most important trends.

If an AI agent can write thousands of lines of code without much human intervention, someone still needs to determine whether those thousands of lines are correct.

That means testing becomes even more valuable.

Automated testing, static analysis, security scanning, benchmarks, simulations, and AI-based code review could become standard parts of AI-assisted development.

The question will increasingly change from:

"Can AI write this?"

to:

"How can we prove that what AI wrote actually works?"

This could also change the skills expected from programmers.

A developer who understands how to evaluate a system may become more valuable than someone who is simply very fast at manually writing code.

5. Multi-agent development will probably become normal

Why use one AI agent when several can work on different parts of the same problem?

One agent could analyze the requirements.

Another could write the backend.

Another could work on the frontend.

Another could generate tests.

Another could review the implementation.

A final agent could run everything together and look for problems.

This sounds excessive today, but agent orchestration is already becoming an important direction in AI development.

The interesting part is that the developer may increasingly become the person coordinating the whole system rather than manually performing every step.

Programming could start looking less like writing every sentence yourself and more like managing a team of extremely fast but imperfect assistants.

6. Context and memory will become a competitive advantage

One of the biggest limitations of AI coding tools is context.

A model can be very capable and still produce a bad solution if it does not understand the project.

It needs to know the architecture, coding conventions, previous decisions, dependencies, documentation, issues, and sometimes even why a strange piece of code exists in the first place.

That makes long-term memory and project context extremely important.

I expect future coding environments to know much more about the project before the developer even asks a question.

Instead of repeatedly explaining:

"This file works this way because..."

the environment may already know.

That could make AI programming much more useful, but it could also make development environments significantly more complex.

7. Vibe coding will survive, but serious software will move toward structure

Vibe coding has become popular because it makes software development much more accessible.

You can describe an idea, generate an application, change things through natural language, and see the result without understanding every part of the implementation.

I don't think that is going away.

In fact, I expect even more people who are not professional programmers to build software this way.

But there will probably be a separation.

For prototypes, personal tools, experiments, and small applications, vibe coding can be enough.

For systems handling money, personal information, healthcare, infrastructure, or millions of users, someone still needs to understand what is happening underneath.

The easier it becomes to create software, the more important the distinction between "it works" and "it is reliable" becomes.

8. More people will become software creators

This might be one of the most positive effects of AI programming tools.

The number of people capable of creating software is no longer limited to people who spent years learning how to code.

A designer can build a prototype.

A researcher can create a data-processing tool.

A business owner can automate an internal process.

A student can build an application for a university project.

This does not mean all of these people will become software engineers.

But they may not need to.

AI could make programming more like spreadsheets or website builders: something that specialists use professionally, but that many other people can use when they need it.

9. Local and open AI will become more interesting

There is another direction I think will receive much more attention: running capable AI closer to the user.

Cloud models are incredibly powerful, but they also introduce costs, latency, privacy concerns, and dependence on external services.

As models become smaller and hardware becomes more capable, running useful AI locally becomes more attractive.

For developers, this could mean having coding assistants that can work with private repositories, sensitive documents, or internal systems without sending everything to an external service.

The most capable model will not always be the most useful one.

Sometimes the best model will be the one that is fast, cheap, private, and available exactly when you need it.

10. Programming education will have to change

This one is particularly interesting to me.

If AI can write code for students, universities will have to reconsider what it means to teach programming.

Simply asking students to write a program may become a poor way of evaluating whether they actually understand programming.

We may see more emphasis on debugging, system design, explaining decisions, reviewing AI-generated code, and solving problems without assistance when necessary.

Students may also need to learn something new:

How to use AI without becoming dependent on it.

That balance could become a skill of its own.

So, what will the programmer of the future look like?

I don't think the answer is "someone who doesn't code anymore."

I think it will be someone who understands software deeply enough to direct machines that can write it.

They will still need programming fundamentals.

They will still need to understand algorithms, systems, databases, networks, security, and architecture.

But they may spend less time manually implementing every detail.

Instead, they could spend more time deciding what should be built, describing the requirements, reviewing the results, testing the system, and deciding whether the solution is actually good.

That sounds very different from the way I learned programming.

And that may be the most interesting trend of all.

AI is not simply becoming another programming tool.

It is changing what the word "programming" might mean.

We spent decades making computers easier for humans to program.

Now we may be entering a period where we are making computers capable of programming themselves — while humans increasingly decide what they should build.

I'm not sure where that ends.

But I think the next few years will tell us whether AI primarily makes programmers more productive, or whether it fundamentally changes who needs to be a programmer in the first place

The Shortest Revolution: How AI Is Changing the Speed of Human Progress

Williams — Mon, 14 Sep 2026 15:50:03 +0000

There is something unusual about the way artificial intelligence is developing.

Humanity has always built tools to make difficult things easier.

The steam engine helped us produce mechanical power on a scale that human muscles simply couldn't match. Electricity then transformed how machines, factories, cities, and communication systems worked.

But AI is doing something different.

For the first time, we are building tools whose main purpose is not to make our bodies stronger or our machines more powerful.

It is trying to make our cognitive work faster.

And the speed at which this is happening is difficult to ignore.

From muscles to machines to intelligence

The Industrial Revolution did not happen overnight.

The steam engine required factories, railways, mines, transportation networks, and enormous amounts of physical infrastructure.

Electricity brought another transformation, but it also required power plants, cables, electrical systems, appliances, and entire cities to be redesigned around it.

AI has a very different advantage.

Its infrastructure is still enormous — data centers, chips, electricity and networks are absolutely necessary — but once a capable model exists, improvements can be distributed through software.

You don't need to build a new railway to make a model better.

You don't need to replace every machine in a factory.

Sometimes, you update the model.

And suddenly, millions of people can have access to a new capability.

That difference may be one of the most important things about AI.

We are only a few years into this

The timeline is also surprisingly short.

GPT-3 was released in 2020, but the moment that made generative AI a mainstream product came with ChatGPT on November 30, 2022.

GPT-4 followed in March 2023, already showing strong performance across professional and academic tasks and accepting both text and images as input.

Then the development accelerated.

AI went from answering questions to writing code.

From writing code to using tools.

From using tools to navigating websites.

From navigating websites to interacting with software.

And from doing individual tasks to completing sequences of tasks.

GPT-5, for example, was already designed to work as a coding collaborator, fixing bugs, editing codebases and performing longer chains of tool calls.

GPT-5.4 then pushed computer use further, allowing models to interact with computers through visual interfaces and perform real tasks across websites and software.

Now we have GPT-6 Astra.

And the difference is not simply that it gives better answers.

It is increasingly able to do things.

The prompt is becoming less important

Early generative AI had a very particular relationship with the user.

You had to explain what you wanted.

Then you had to correct the model.

Then you had to explain what it misunderstood.

Then you corrected it again.

A good result often depended on knowing how to write a good prompt.

Astra points toward something different.

OpenAI says the model can handle multi-step workflows across code, browsers and professional software. It can also fill in routine gaps when an instruction is incomplete and ask questions when missing information could change the result.

That sounds like a small improvement.

It isn't.

It changes the relationship between the human and the machine.

The question is slowly moving from:

“How do I tell AI exactly what to do?”

to:

“What do I want AI to accomplish?”

That is a much bigger change.

From answering to operating

Consider something as simple as a spreadsheet.

A traditional chatbot might explain how to create a financial model.

A more advanced system can actually work with the spreadsheet.

Astra is designed to create and modify documents, presentations and spreadsheets while following existing templates and styles.

The same idea extends to software.

Instead of asking:

“How do I fix this bug?”

you can increasingly ask an AI system to find the bug, modify the code, test the result and report back.

And then there are tasks that would have sounded ridiculous only a few years ago.

OpenAI demonstrates Astra working inside Blender, creating a 3D house and turning it into a walkable Unreal Engine scene.

That is not simply text generation.

The model is interacting with professional software to produce something that exists outside the conversation.

The chatbot is becoming an interface to other tools.

And then there is the problem of reality

AI-generated images and videos have created another interesting change.

There was a time when fake images were relatively easy to identify.

Then they became convincing.

Then video generation started producing scenes that could look surprisingly realistic.

OpenAI's Sora 2, for example, was designed specifically for more physically accurate and controllable video generation, with synchronized dialogue and sound.

This creates a strange situation.

The problem is no longer simply:

“Can AI create something that looks real?”

It increasingly can.

The problem becomes:

“How do I know whether something I am seeing is real?”

That is a very different challenge.

And it is another example of how quickly the technology is moving.

The most surprising example may be mathematics

Perhaps the clearest sign of where this could lead appeared only days ago.

On September 8, 2026, OpenAI announced that an internal AI system had produced a proposed solution to the Navier–Stokes existence and smoothness problem, one of the seven Millennium Prize Problems.

These equations describe the behavior of fluids, and the problem has remained unresolved for roughly 90 years.

OpenAI says its system produced a proof and a formalization in Lean. It also says the internal system was significantly more capable than GPT-6 Astra.

But there is an important detail.

We should not simply declare that AI has officially solved a Millennium Prize Problem.

The result still needs independent mathematical verification, and the announcement has already generated controversy around the use of previous research and questions of priority.

Still, even if the proof eventually requires corrections, the event itself is remarkable.

A machine is being used to attack a problem that humans have struggled with for decades.

And this raises a much bigger question.

What happens when intelligence becomes a tool?

The steam engine gave humans more physical power.

Electricity gave machines an enormous amount of flexibility and scale.

AI is beginning to give individuals access to something different: cognitive leverage.

A student can ask questions that would previously require searching through several books.

A programmer can generate and debug code.

A designer can create a 3D prototype.

A business can automate repetitive workflows.

A researcher can process enormous amounts of information.

A person with no experience in a professional tool can sometimes use natural language to operate it.

This doesn't mean expertise has become useless.

In fact, the opposite may be true.

As AI becomes more capable, knowing when its answer is wrong becomes more important.

Understanding the fundamentals becomes more important.

Being able to verify its work becomes more important.

The machine can increasingly do the execution.

Someone still needs to decide whether the execution makes sense.

Maybe this is why AI feels different

The steam engine changed what humans could physically do.

Electricity changed what machines could do.

AI is starting to change what individuals can think through and accomplish with the help of a machine.

And there is another difference.

The steam engine did not improve itself every few months.

Electric motors did not suddenly become better because someone uploaded a new version of their software.

AI systems can.

That creates a strange feedback loop:

better models → more useful tools → more users → more applications → more investment → better models.

The amount of time between one capability and the next keeps getting shorter.

ChatGPT became publicly available in late 2022.

It feels like a completely different technology today.

And GPT-6 Astra may already be another step toward a world where AI isn't simply answering us.

It is working alongside us.

We may not be watching another Industrial Revolution

Maybe calling AI the “next Industrial Revolution” isn't quite right.

It could be something different.

The Industrial Revolution multiplied our physical power.

The digital revolution multiplied our ability to store and transmit information.

AI may multiply our ability to turn information into action.

And that might be why its development feels so unusually fast.

The most important question may not be whether AI will replace programmers, designers, researchers, students, or other professionals.

It may be something much harder to answer:

What happens when the amount of work one person can accomplish is no longer limited by how quickly that person can personally perform every step?

We are still very early in finding out.

And if GPT-6 Astra is any indication, the next few years may be less about AI becoming a better chatbot...

and much more about AI becoming a general-purpose collaborator capable of doing the work itself.

That is probably the most important shift to watch.

Not because machines are suddenly becoming human.

But because, for the first time, humanity has built a tool that can increasingly participate in the process of producing knowledge, software, designs, research and decisions.

And unlike the steam engine or the electric motor, this tool is improving while we are still learning how to use it.

That may be what makes this revolution different.

When Coding Gets Too Easy

Williams — Wed, 09 Sep 2026 14:18:30 +0000

Programming has never been particularly easy.

You write something, run it, and it breaks.

You fix it, and something else breaks.

You spend twenty minutes looking at the same line of code before realizing that you forgot a single character.

It can be frustrating.

But that frustration is also part of learning.

Now, AI can remove a lot of it.

And I'm not sure that's always a good thing.

The easiest way to write code

Since ChatGPT became popular, programming has changed considerably.

If you don't remember how to use a library, you can ask.

If you don't understand an error, you can paste it into a chatbot.

If you don't know how to implement something, you can describe what you want and get a working example.

For programmers, this is obviously useful.

For programming students, it can be even more useful.

When I started university, ChatGPT was already part of the programming experience. It was an incredibly convenient tool. Whenever I got stuck, I could ask for help instead of spending a long time searching through documentation or trying different solutions.

And eventually, there was a period where I relied on it too much.

A lot of the code I was writing was generated with AI. It made everything faster, but I started noticing something that I didn't expect.

I was becoming less comfortable with small problems.

Things like syntax errors, for example, became more annoying than they should have been. When you constantly have an AI writing or correcting your code, you don't necessarily get the same practice of making mistakes yourself.

The code was getting better.

My ability to write it from scratch wasn't always improving at the same speed.

That made me realize something: making programming easier can sometimes make learning programming harder.

The struggle actually matters

When you're learning to program, mistakes are not just obstacles.

They are feedback.

You forget the syntax of something, make a mistake, see the error, and eventually remember it.

You don't understand why a loop behaves differently than expected, so you investigate it.

You try three approaches that don't work before finding one that does.

Those experiences stay with you.

AI can skip many of those steps.

Instead of struggling with an error, you can ask AI to explain it.

Instead of trying to design an algorithm, you can ask AI to create one.

Instead of remembering syntax, you can generate the code and move on.

That's fantastic when the goal is productivity.

But learning and productivity are not always the same thing.

Sometimes the part we want to eliminate is exactly the part that teaches us.

This doesn't mean AI is bad for programmers

It would be unfair to blame AI for this.

Programmers have always looked for ways to make their work easier.

We use libraries instead of writing everything from scratch.

We use frameworks.

We use autocomplete.

We search documentation and Stack Overflow.

We reuse code all the time.

The goal of programming has never been to suffer as much as possible while writing code.

The difference is that AI can now do something much closer to the thinking process itself.

And that's where things become interesting.

A library saves you from writing something yourself.

AI can potentially save you from figuring out how to write it at all.

There is a big difference between those two things.

The next step could be even bigger

And we're probably still at the beginning.

With the next generation of AI models, such as GPT Astra 6, programming assistance could move much further.

Instead of asking an AI to write a function, you might give it a feature and let it work through the entire process.

It could understand the codebase, modify several files, run tests, find problems, fix them, and try again.

At that point, typing code might become one of the least important parts of software development.

That could be incredibly productive.

But it also raises an uncomfortable question:

If AI does more of the programming process, how do we make sure programmers still understand programming?

The fundamentals become more important, not less

It might seem like AI makes learning the fundamentals unnecessary.

I think the opposite is true.

The better AI becomes at writing code, the more important it becomes to understand what that code is doing.

Otherwise, you can end up in a strange situation where your AI-generated program works, but you don't really know why.

And that becomes a problem the moment something goes wrong.

You can't properly debug code you don't understand.

You can't judge whether an implementation is unnecessarily complicated if you don't understand the alternatives.

And you can't tell whether an AI solution is good just because it compiles.

This is probably why the advice to "learn the fundamentals" isn't going away anytime soon.

The fundamentals may actually become the thing that separates someone who uses AI to program from someone who simply asks AI for programs.

Maybe we don't need to write everything anymore

I don't think the answer is to stop using AI.

That wouldn't make much sense.

If a tool can save programmers hours of repetitive work, we should probably use it.

The important part is knowing what we are giving up in exchange for that convenience.

If I'm working on a real project and AI can generate some boilerplate code in seconds, great.

If I'm learning a new concept and AI immediately solves the entire problem for me, maybe I should stop and try it myself first.

The difference isn't really between using AI and not using AI.

It's between using AI to make yourself more capable and using AI so that you don't have to become capable in the first place.

And I think that distinction is going to become increasingly important.

Programming was never just about writing code

Maybe that's the biggest lesson here.

Programming isn't valuable simply because you can type code into a computer.

It's valuable because you can understand a problem, break it down, reason about possible solutions, recognize when something is wrong, and decide what should happen next.

AI can help with all of that.

But if we let it do everything, we might slowly lose the opportunity to practice those skills ourselves.

When I look back at how I used AI when I first started programming, I don't regret using it.

It helped me a lot.

But I also wouldn't want to go back to a point where I couldn't solve a problem without asking it first.

Because sometimes, the struggle isn't getting in the way of learning.

The struggle is the learning.

And as AI gets better, knowing when to let it help — and when to put it aside — might become one of the most important skills a programmer can have.

And do you think coding has become easier🤔?

Can Longitudinal Memory Help Combat Academic Burnout?

Williams — Wed, 24 Jun 2026 16:08:52 +0000

It is two in the morning, and a university student is still staring at the same concept they were supposed to understand days ago.

After several failed attempts, they open an AI assistant and ask for help. The response arrives instantly. It is technically correct, detailed, and well structured. Yet somehow it does not help. The student asks for another explanation, then another. Each response becomes longer, while understanding remains out of reach.

The assistant knows the answer.

What it does not know is the person asking the question.

As AI becomes increasingly integrated into education, this limitation raises an interesting question: what if these systems could remember our learning journey over time? More specifically, could an AI assistant equipped with longitudinal memory help reduce some of the conditions that contribute to academic burnout?

Academic Burnout Is More Than Exhaustion

Burnout is often discussed in professional settings, but students are not immune to it. Academic burnout goes far beyond feeling tired after a demanding week. It is commonly associated with emotional exhaustion, declining motivation, and a growing sense of detachment from academic responsibilities.

In highly competitive environments, these conditions can become difficult to recognize precisely because they are so common. Long study sessions, chronic sleep deprivation, and constant pressure are frequently treated as normal parts of the educational experience. In some cases, students even begin to associate exhaustion with productivity, viewing extreme sacrifice as a prerequisite for success.

The problem is that learning does not scale indefinitely with effort. As cognitive fatigue accumulates, concentration deteriorates, comprehension slows down, and frustration becomes increasingly difficult to manage.

The Paradox of Today's AI Assistants

Over the last few years, AI assistants have become a routine part of student life. They explain concepts, summarize readings, generate exercises, and provide answers within seconds. For many learners, they have become as accessible as search engines once were.

Yet there is a paradox at the center of these systems.

They possess an extraordinary amount of knowledge about the world while knowing almost nothing about the individual using them.

Most large language models were originally designed around short-term conversational context. Although memory systems and personalized agents continue to evolve, many interactions still resemble isolated exchanges. The assistant responds to the prompt in front of it without understanding the broader learning trajectory behind that prompt.

Two students may ask the exact same question about neural networks. One may have a strong background in calculus and linear algebra. The other may still struggle with fundamental mathematical concepts. To an assistant without persistent memory, they appear nearly identical.

From an educational perspective, however, they are not.

Why This Matters Now

The timing of this discussion is not accidental.

For the first time, a significant portion of students rely on AI systems as part of their daily academic workflow. These tools are no longer occasional resources used to solve isolated problems. Increasingly, they function as tutors, study companions, and sources of feedback throughout the learning process.

At the same time, educational systems continue to place substantial demands on students. The combination of growing academic pressure and increasingly personalized technology creates a new opportunity: AI systems that understand not only what students ask, but also how they learn.

Whether that opportunity should be pursued remains an open question.

What Is Longitudinal Memory?

Longitudinal memory refers to the ability of a system to retain and make use of relevant information across extended periods of time.

Instead of treating every interaction as a new beginning, an assistant could gradually develop a richer understanding of the user. It might recognize recurring misconceptions, preferred learning styles, patterns of progress, or topics that consistently generate difficulty.

Human mentors naturally do something similar. After working with a student for months, they often develop an intuitive understanding of that person's strengths, weaknesses, habits, and emotional responses to academic challenges.

An AI system would not replicate that relationship exactly. However, it could potentially identify patterns across a much larger volume of interactions than any individual mentor could reasonably track.

A Possible Tool Against Burnout

If implemented responsibly, longitudinal memory could allow educational assistants to provide support that extends beyond answering questions.

Consider a student who repeatedly struggles with advanced material late at night. Over time, the system might identify a pattern between fatigue and declining comprehension. Instead of generating increasingly detailed explanations, it could adjust its response strategy, simplify concepts, recommend a break, or postpone certain tasks until a more productive moment.

Likewise, an assistant could recognize recurring signs of frustration surrounding particular subjects and adapt its teaching approach accordingly. Rather than responding exclusively to the immediate request, it would respond within the context of a longer educational history.

This does not mean AI should replace self-discipline, personal responsibility, or human support systems. Rather, it suggests a shift from reactive educational tools toward systems that possess a deeper awareness of the learner behind the prompt.

The Tradeoffs

The promise is compelling. So are the challenges.

A system capable of detecting patterns related to cognitive fatigue would require access to a substantial amount of personal information. Study habits, learning difficulties, behavioral trends, and potentially emotional indicators could all become part of its memory.

The first concern is privacy. Who controls that information, and how is it protected?

The second concern involves accuracy. Human behavior is complex, and mistakes in interpretation are inevitable. A student experiencing temporary exhaustion could be misidentified as disengaged. A short-term decline in performance could be interpreted as a deeper problem that does not actually exist.

There is also a broader question worth considering: at what point does a study assistant stop being a tool and start becoming a companion?

As educational AI becomes more personalized, the boundary between assistance and dependence may become increasingly difficult to define.

Looking Ahead

Longitudinal memory will not solve academic burnout on its own. Institutional pressures, social expectations, and personal circumstances will continue to shape the student experience regardless of how advanced educational technology becomes.

Nevertheless, it points toward an interesting shift in how we think about AI in education.

For decades, educational technology has focused primarily on improving access to information. Today, information is abundant. Understanding the learner is a far more difficult challenge.

Perhaps the next generation of educational assistants will not be defined by how much they know, but by how well they understand the people they are designed to help.

Whether longitudinal memory becomes a meaningful educational innovation or an ethical cautionary tale remains uncertain. What is clear is that the conversation is only beginning.