The meeting room at WorQflow Labs was quiet. The entire software development team of ten sat gathered around a big screen, watching as the recently-installed beta AI development environment did its thing. While aware of the growing noise in their communities of choice, this was the first time they’d actually had a chance to see it in action. No one had their laptops open, which was highly unusual. They were simply watching in silence.

For the first hour, the AI agent had done nothing but interact with their test environment, safely clicking around and exploring the WorQflow UI. Then, with a few nervous laughs, they’d said “bon voyage” as they gave it permission to ingest their entire codebase. It started quietly mapping relationships, dependencies, logic, variables… every hack, every quick fix, diving into the full legacy stack. Nervous looks were exchanged - they knew it was a bit messy.

Then the screen had flashed up a message:

AUDIT COMPLETE. TESTS GENERATED. REVIEW NEEDED.

A list filled the screen, outlining documentation they wish they’d written years ago. Their system’s behaviour was listed out in crisp, clear statements that - in combination - described all of the rules and business logic that made WorQflow behave as intended. Many statements were eerily accurate, as if the AI had been in the room with them all these years. Some statements seemed a bit off. A few capabilities seemed to be missing entirely.

Liam, the most senior developer in the room, let out a slow breath. “This thing thinks it knows our product better than we do.”

Tom, the founder, stood with his arms crossed, watching the screen with an expression that meant he was already thinking ten steps ahead. He nodded slightly. “Well. Does it?”

Nobody answered at first.

Then Marie, their lead QA, started to scroll through the list, scanning quickly. “This is quite… interesting. Really interesting actually. Wait, this statement doesn’t account for how we handle failed exports.”

James, the youngest on the team, leaned forward pointing. “And that one assumes we always allow full admin control over team workflows. But it’s supposed to be configurable.”

Sarah frowned. “I mean, a hell of a lot of this is pretty much spot on. But also—where on earth did it get some of these ideas? ‘Content library’ - never heard of it!”

They began to suspect why. The AI had seen everything—every rushed deadline fix, every workaround stacked hastily on top of problematic functions, every accidental rule they’d never meant to create. Even old capabilities commented out in favour of refactoring.

Liam rubbed his face. “I don’t know if I should be impressed or offended.”

Tom leaned in, still focused on the screen. “This is interesting. If we confirm what’s correct, where it’s wrong, and what’s missing, we can let it start a build. Come on, we’ve got work to do. ”

Nobody spoke for a minute. Then Marie pulled her laptop toward her. “Okay. Let’s do it.”

For two hours, they picked through the AI’s suggestions, debating business logic, correcting mistakes, adding what it had missed. When they were done, they looked at each other and hit confirm after a roomful of nods.

The AI processed for a moment. Then:

BUILD INITIALISED. CODE AGENTS: 5000.

The room froze.

Marie blinked. “I’m sorry, does that say five thousand?”

James sat up straighter. “What the hell?”

Behind the scenes, an endless stream of build attempts span up—failures, optimisations, rewrites. Code was being generated at a scale none of them could comprehend. It wasn’t testing one idea at a time; it was generating them all in parallel, and on screen a large matrix of status indicators was beginning to flicker between blue, amber and red.

Sarah’s voice was quiet, careful. “What’s it doing? Is it brute-forcing a solution? How is that going to work?”

Liam exhaled slowly. “Maybe it’s trying to evolve one?”

They watched, saying less and less. The AI wasn’t fixing their code. It wasn’t even diligently refactoring. It was attempting to generate it from scratch.

At first, the tests all failed—0/834 passing. Then, slowly, the numbers climbed. 4/834. 23/834. 127/834. By hour four, more than half had passed. The people in the room, having drifted back to their own workstations, slowly returned as the count passed 800. By hour six, only one test was still failing.

James got up and paced at the back of the room. “I feel kind of sick.”

Marie had gone still, staring at the screen. “I can’t decide if this is the best or worst thing I’ve ever seen.”

Then, just before the seven-hour mark—

834/834 TESTS PASSED. BUILD COMPLETE.

Nobody moved.

Sarah was the first to speak. “So… what does it look like?”

James hesitated, then opened the generated code. He exhaled slowly. It was unrecognisable. No familiar functions remained. The structure was something entirely new—elegantly documented, precise in a clinical way, and entirely mysterious to them all.

Liam shook his head slowly. “I don’t even know what I’m looking at here.”

Marie scrolled through the files, searching for anything that resembled their old system. She found nothing. “Did it just rewrite our entire product from scratch?”

Sarah exhaled. “It must have. And look, the codebase is half the size it was before.”

Tom stepped forward at last, eyes locked on the screen. “But does it work?”

James spent a few minutes running their existing - and incomplete - test suite. Every check came back green. It passed. By these metrics, it was perfect.

Liam folded his arms, shaking his head. “We’re supposed to maintain this? Debug it? What happens if something breaks?”

Tom didn’t answer. Nobody did.

Marie sat back, glancing between the test results and the code. Then she let out a dry, almost-laugh. “So this is it, then? This is software development now?”

James exhaled through his nose. “I think we just made ourselves obsolete.”

Tom kept staring at the screen, as if trying to see through it. “I disagree,” he said quietly. “But we’ve just had a taste of the future. Though we’re never going to release something we don’t fully understand and trust. Right?”

Liam breathed out heavily. He tapped his finger against his chin. “No, no of course. I’m… not sure where I am with all this,” he began, “it was both impressive and, frankly, existentially terrifying. I’m going to spend a good few days reviewing its output to see what on earth it came up with.”

Analysis

This year, AI promises to become an active participant in shaping codebases, making architectural decisions, and managing deployment. I’ve chosen to focus this future fiction scenario on the engineering side of software development because it looks increasingly likely to be the tipping point. Software development as a cluster of adjacent professional skills (product, design, engineering, marketing, sales etc.) is on the cusp of big change. The transition is likely to be a choppy crossing of uncharted waters for all of these roles. It’s hard to imagine an optimistic future until we reach the other side and start to experience shared benefits, so this scenario differs from my usual fare by looking only a few years ahead.

In the story, the AI-driven system produces working software, and the team suddenly feels a sizeable shift in their relationship to it. With an unfamiliar codebase, any traditional sense of ‘ownership’ becomes confounded. When AI can take on large scale rewriting and optimisation - and still produce working code - human developers will struggle to stay on top of the sheer volume of change via code review. And once a software development team no longer feels full ownership of their code, an entire industry will start to tip into the future.

A few shifts will define the progression of AI-driven software development:

Once AI systems can regenerate entire codebases reliably and cheaply, businesses will gain a remarkable level of adaptability. Features that go unused could be stripped down or pivoted with ease. Integrations that would have taken many months could be complete in hours. This will lead to a rapid gold-rush era of software where any monetisable value proposition is up for grabs, countered by the rapid response of open-source software that is suddenly as good as its paid counterpart. From a value chain perspective, this represents a sharp lurch toward commoditisation: always on and cheap to use. There will be a simultaneous race: to the top for capabilities and personalisation, and to the bottom for price. Perhaps energy, compute and data will become the remaining value centres - and they are being built for economies of scale right now.

When mapping a value chain, commodities can progress into a state of evolution. My bet is that with software being increasingly tailored to specific use cases and ever-smaller and more specific segments, there is a pretty straight line to a future where everybody simply generates the software that they need at any given moment for the task at hand. Software ultimately becomes an impermanent layer capable of gluing contextual needs to results using whatever modality best suits the individual.

And that’s where Optimistic Futures really begins.