Thesis: GenAI is a platform shift
Key question#2: Is GenAI changing the way software products are built?
In my previous article, I explored the concept of platform shifts, examining whether and how GenAI might represent such a shift in the software world. I defined a platform shift as the combination of both a technological shift and a business model shift and I briefly discussed why GenAI is undoubtedly a technological shift, given its capacity to efficiently leverage unstructured data.
However, the distinction between true disruption and mere expansion depends on GenAI's ability to reshape digital business models at their core. It is primarily through innovative business models that software startups typically build defensible moats, preventing incumbents, copycats, and competitors from replicating their approach when it poses a threat.
Therefore, understanding whether GenAI can trigger new business models in the digital domain is crucial for VCs to develop a compelling investment thesis on whether to invest in the application layer emerging from this novel technology.
I ultimately proposed looking for the first signs of change by investigating value creation mechanisms, rather than potential shifts in value distribution, which has traditionally been seen as the primary driver behind the emergence of new startups during previous platform shifts like the internet, PCs, smartphones, and cloud technologies.
Let’s continue our journey from here.
In my search for a solid starting point to anchor my investigation, I found a key reference in Andrej Karpathy’s seminal essay titled Software 2.0 (he also presented this concept in an insightful 2018 talk, available here). This idea has since evolved, with the rise of LLMs, leading to the emergence of Software 3.0 framework, which builds on the foundation of Software 2.0 and expands the possibilities for how AI integrates with software development.
In his article, Karpathy distinguishes between two key paradigms in software development: Software 1.0 and Software 2.0.
Software 1.0 represents the traditional approach, where programmers wrote explicit, line-by-line instructions using languages like Python or C++. Every behavior and function of the program is manually defined by the programmer. In contrast, Software 2.0 relies on machine learning models, particularly neural networks, which are trained rather than explicitly coded.
Instead of writing the logic by hand, developers in Software 2.0 use predefined architectures and training frameworks to set up neural networks and define the desired outcomes. The model is then trained on data, and the "logic" emerges as the system optimizes itself based on patterns within the data.
In Software 1.0, developers focused on designing algorithms and hard-coding the software’s logic. In Software 2.0, the developer's role includes also curating, growing, and refining labeled datasets, allowing the system to explore and optimize complex problem spaces, approximating solutions that would be nearly impossible to code manually.
Neural networks are not just another classifier, they represent the beginning of a fundamental shift in how we develop software. They are Software 2.0.
With the rise of foundational models, the Software 2.0 paradigm has evolved even further, giving way to Software 3.0. In this new framework, instead of focusing on training models or writing code, developers "simply" interact with an AI agent through natural language prompts.
In Software 3.0, programming now revolves around “prompt engineering”, the task of crafting well-formed natural language prompts to query an AI agent for the desired output.
This perspective has recently sparked speculation about an apocalyptic “end of software” scenario, where LLMs drive software costs (and barriers) toward near-zero, triggering a Cambrian explosion of products while eroding the ability to consistently capture value.
Now, let's assess how close we truly are to this possibility.
Much like quantum mechanics, where light behaves both as a particle and a wave, GenAI in software development displays a dual nature depending on the perspective applied: it can be seen both as a code function and as a function generator.
GenAI as a function: LLMs can be seen in the software domain as a new function, capable of processing new categories of inputs and returning different types of outputs. They expand the possibilities of interaction between data and software, opening up new use cases and opportunities for automation.
GenAI as a function generator
Alternatively, LLMs can be seen as a novel platform to generate code, automating the creation of functions. It allows developers to build software more quickly and flexibly, without relying on traditional, manual development workflows.
GenAI as a function
GenAI adds a new tool to the software development arsenal, expanding the range of programmable tasks and the use cases for automation. It offers more powerful means to address a broader set of challenges, enabling software to handle complex scenarios through natural language understanding and output generation. By incorporating reasoning and interpreting inputs in a more human-like way, GenAI significantly enhances what can be achieved through software (driving the technology shift we have already discussed).
Given the primary goal of my analysis, I focused my attention on the key enablers required to effectively integrate GenAI into software products: data infrastructure and competencies, evaluating whether GenAI is driving significant shifts from current development practices in these two areas.
Since the success of any AI initiative is intrinsically tied to the quality, reliability, and performance of the underlying data infrastructure, the first question I addressed was whether GenAI is fundamentally altering how the data stack needs to be built to fully unlock the potential of inference functions.
For the evidences I have gathered so far, the answer seems to be negative: GenAI acts as an accelerator, introducing automation, modularity, and new orchestration opportunities, but it operates within an existing, evolving framework.
The current stack handles structured data effectively while advancements in automated data labeling and feature engineering tools are making it easier to handle unstructured data in ways that fit into existing infrastructures.
Despite some suggesting the arrival of a "post-modern data stack," where AI’s transformative power could render current architectures obsolete, the modern data stack seems already designed to be modular and scalable. GenAI seems to operate within the existing even if evolved framework. Companies can integrate GenAI capabilities incrementally, enhancing existing systems rather than replacing them entirely.
I conducted a similar investigation into the skills required to embed the inference function into a software product and found interesting results.
From a technical point of view, the answer remains negative. The rise of the AI Engineer role seems to represent a natural blend of software development and data engineering, rather than an entirely brand-new discipline. These engineers focus on applying and productizing AI systems using available tools and APIs, often without needing deep expertise in model training or foundational research.
When it comes to shipping AI products you want engineers, not researchers. Unsurprisingly, an extensive analysis of 417 AI companies from YC's 2023 and 2024 cohorts found that only 8% of startup founders come from academic research backgrounds, such as PhDs or postdoctoral researchers.
However, I discovered fascinating insights while speaking directly with people building AI-native products today, consistently encountering a key pattern: the shift from mapping business processes to mapping mental processes.
To effectively teach LLMs to automate tasks, domain expertise is required to model the skills and logical steps (i.e. chains of thought) that a human expert would follow, embedding the “synthetic skillset” into a protocol that a machine (i.e. an agent) can execute.
In this new landscape, it’s not just about integrating AI into workflows; it’s about teaching the machine to "act" like an expert human, replicating the reasoning and logical steps required to solve complex tasks. This mental process modeling is vital for GenAI to handle non-statistically obvious use cases autonomously, yet it remains surprisingly underrated in the broader narrative.
GenAI as a function generator
By raising the level of abstraction and viewing LLMs as linguistic models capable of interpreting and generating text, GenAI unlocks a new programming platform, streamlining the coding process in multiple ways.
In recent years, GenAI has not only augmented traditional tools but also triggered an explosion of new coding technologies, co-pilots, agents, and code-specific models, attracting $3.9 billion in VC investment in 2023 alone. These innovations aim to enhance or fully automate various engineering workflows, offering different levels of integration depending on the tasks addressed.
AI copilots enhance engineering workflows by integrating seamlessly with developers' tools, while AI agents perform engineering tasks end-to-end, automating processes from writing code to testing and reviewing. Code-specific foundation models, tailored to the tasks of coding, are instead trained on code-specific data and vertically integrated with user-facing applications.
The data I’ve gathered so far suggests that GenAI’s strength lies in enhancing engineering workflows by automating the more tedious aspects of programming, such as code writing, navigation, and maintenance.
Code generators like GitHub Copilot, powered by OpenAI's Codex, frequently produce code that appears reasonable. In fact, by 2023, around 40% of the code generated by Copilot is accepted without modification. Google has also reported even better acceptance rates. More recently, in September, OpenAI's o1 model, a large language model trained with reinforcement learning to perform complex reasoning, delivered surprising results in simulated competitive programming contests, demonstrating significant advances in coding skill.
But code generation is not the only key aspect: Most time coding is not taken up in writing code, but with designing, debugging, and maintaining code. AI tools like Copilot, while effective at generating lines of code, struggle with complex tasks due to their statistical nature and may complicate code review and debugging, as developers end up sifting through redundant or inconsistent parts, forcing developers manually fix and optimize AI-generated code, diminishing the time saved.
A more advanced approach is emerging with tools like Qodo (formerly CodiumAI), which go beyond code generation to formalize specifications, enhance debugging, and ensure quality throughout the process. This "flow engineering" approach shifts from basic prompt-based generation to a more structured, iterative framework that integrates problem analysis and solution formulation with testing and refinement, making AI-generated code more accurate, maintainable, and aligned with real-word operational needs.
With the rapid rise of these tools, it is easy to revert to the idea of the looming "software apocalypse" I mentioned earlier. However, this scenario is fundamentally flawed for one simple reason:
English, like any natural language, is inherently ambiguous and, therefore, unsuitable for programming.
While GenAI brings us closer to interacting with machines using natural language, programming requires logic and absence of ambiguity, something neither natural languages nor all humans can guarantee by default. Developers eliminate ambiguity by modeling problems into discrete protocols, a core skill that is unique to developers and not inherent in every human professional.
Historically, programming has evolved through increasing layers of abstraction, from machine code and assembly to higher-level languages like C and Python, which has progressively delegated complexity management from humans to machines. Each layer abstracts more complexity, simplifying developers' workflows while ensuring clear, unambiguous instructions for machines. For instance, modern tools like Swift's LLVM architecture already convert code into bytecode and optimize it beyond human readability.
This evolution is not new: GenAI should be seen as another enabler in this ongoing abstraction process towards natural language, not as a magic tool that will turn everyone into a software developer.
All the elements gathered so far suggest that AI enhances development processes by automating labor-intensive, repetitive tasks, without reducing human involvement to mere prompt writing. This shift allows for a higher level of abstraction, enabling teams to work more efficiently and focus on tasks that require deeper creativity and problem-solving.
The combination of these factors is far from an apocalyptic scenario; rather, it lays the groundwork for unlocking significant potential in productivity gains.
Developing for a machine in fact is inherently simpler than developing for a human: machines don’t require detailed explanations, elegant variable names, or well-structured comments. They execute code as long as it is syntactically correct and logically sound.
However, when humans are involved, the process of coding becomes an “act of communication”. Developers must craft code that is not only functional but also readable and maintainable by other humans. This need for human-readable code introduces a layer of complexity that doesn’t exist when writing solely for machines.
By raising the level of abstraction closer to natural language, GenAI simplifies many of these human-to-human coding challenges, allowing developers to focus on problem-solving and logic rather than tedious syntax. The introduction of AI copilots and agents, capable of automating everything from code generation to testing, further reduces these manual burdens. As a result, developers can dedicate more time to higher-order thinking, boosting overall productivity and efficiency.
Rather than signaling the end of programming, GenAI represents a new era, one that broadens the scope of abstraction and introduces a more productive developer platform. This shift enables automation in ways that allow developers to focus on higher-level tasks, making the process faster and more efficient while still preserving the creative problem-solving core of software development.
The widely discussed “democratization of programming” should not be mistaken for the idea that everyone will become a developer. Instead, it is about accessibility: developers of all skill levels can now tap into the most advanced skilled agents, whether it’s the best debugger or the most intelligent Python programmer. This newfound accessibility extends beyond just software development and can be abstracted to the business domain, ultimately enabling organizations to harness cutting-edge AI capabilities without relying solely on elite, specialized talent.
At the same time, developers and software are moving deeper into the business domain, as software begins to "consume" skills and workflows previously handled by humans. This evolution allows AI-powered systems to tackle not only technical challenges but also critical business processes, blurring the lines between engineering and business operations and potentially revolutionizing the way people work within organizations.
In the next chapter, we will explore how these technological shifts could give rise to new business models, transforming not just how code is written but how businesses create value in an AI-driven landscape.
A special thanks in particular to Luca De Pedrini, Stefano Gatti and Bruno Bellissimo for their invaluable review and feedback.
No posts
Comments
Nothing yet. Say the first thing.
Sign in to join the conversation.