RIP software devs, long live software devs

You’ve seen the headlines — the entry-level software developer position is dead. As much as some are willing to bet on that future reality, I will argue we are further away from that reality than most of us think. 

But perhaps the future will resemble an Ironman-style software developer – part human and part machine. A Jarvis for every company, rather than a Devin. And if this is the case, what form factor will this future software developer take? 

Will it be one agent to rule them all — an agentic software developer capable of autonomously doing low-level software development work? Is it an agent for each function – requirements gathering, system design, coding, review, testing/Q+A, deployment, monitoring, and documentation — stitched together in an agentic system? Opinions may differ on how close to either future state we are, but what is clear is that we are in the age of AI-enhanced copilots. 

GitHub Copilot was the first to usher in the generative pair programmer, and the market has quickly evolved. Cognition.ai’s Devin took social media by storm with a demo of a semi-autonomous coding agent, and then the hype deflated a little more recently. There are also companies like Nustrom, whose agents are building side hustles, and Felicis investment poolside, which is putting together an incredible team of deep learning experts to build highly capable ML coding assistants. 

With all this focus, it’s understandable if someone might feel this is reminiscent of the self-driving car phenomenon in the early 2010s. At the time, many investors bet that self-driving cars would be a possibility before the end of the decade, and despite billions of dollars, we are still chasing after full self-driving cars. And while the complexity of the problem may not be equivalent, I would posit we are still far away from fully autonomous agents for software development. The reason is threefold:

• Lack of reasoning. Agents still fundamentally lack the ability to make judgments or decisions based on common sense or experience. Several engineering tasks, from system design to coding and debugging, require human-level intuition and experience. Luckily, several groups are working on AI reasoning, including Fei-Fei Li and the MIT-IBM Watson AI Lab.
• Limited context understanding. Agents perform well in bounded tasks and environments but struggle to extrapolate beyond their training data. This is difficult in a field like engineering that relies heavily on past experience in tackling new, amorphous problems.
• Resource scarcity and data dependency. The equation for a successful AI startup is vast amounts of talent, data, and compute. Most enterprises are hamstrung by some combination of all three, particularly data and compute. Until these issues can be addressed through additional capital and infrastructure, this will continue to be a bottleneck for progress.

Yet there’s no doubt that AI will change the development landscape completely:

• AI is already shifting how we write and build code
• This will surface a whole set of new problems that need new tools
• These problems will spawn new companies

It’s worth considering which parts of the software development stack are most susceptible to automation. To get there, this post will examine:

• The history behind DevOps and how it emerged as a category 
• What has enabled AI software to emerge as a category now
• A framework for which workflows (and, by extension, public companies) are most susceptible to agentic automation
• Where startups have an advantage over incumbents and the opportunities/risks

‍

First, some history

Developer operations and tooling companies have had a 15-year bull run since the start of the early 2010s. The rise of DevOps in the late 2000s/early 2010s can be traced back to a few factors, including:

Standardization of Infrastructure

Standardization of infrastructure accelerated the adoption of the key technologies required for the growth of DevOps companies. This includes:

1. Cloud computing (i.e., AWS, Azure, GCP), which provided the backend infrastructure
2. Containerization, which simplified application scaling
3. Infrastructure as code (IAC), like Kubernetes, emerged as a way to standardize across containers and infrastructure. IaC companies like Hashicorp introduced the ability to manage and provision computing infrastructure, like code, abstracting away the complexity through a standardized language format
4. Microservices architecture, which emerged to compartmentalize and streamline the development process

Software products were developed (and, by extension, companies that commercialized these services) to resolve the problems introduced by the scale and complexity of the new infrastructure stack. Providers like New Relic, Splunk, and Datadog grew to address new sprawling infrastructure observability demands. Docker helped to manage the container creation and management process. Kubernetes, as mentioned above, managed the orchestration process across containers, and Hashicorp abstracted away infrastructure in the form of code. GitLab, CircleCI, and others facilitated faster deployment processes through the CI/CD process. These companies established the foundation for further development tooling, including Twilio, PagerDuty, JFrog, and many others. 

Developer growth and the rise of agile

The U.S. Bureau of Labor Statistics (BLS) reports the number of software developers grew ~4x from 913K in 2010 to 4.2m in 2020 in the U.S. alone, and the worldwide population has been quoted anywhere from ~5-6x that number. This greatly expanded the number of users of Developer operations and tooling products. 

Companies also increasingly adopted agile dev practices. This approach increased the need for developer operations/tools that enabled collaboration among developers and their peers, catalyzing companies like GitHub, Atlassian, CircleCI, and others. 

During the 2010s, numerous developer-related companies went public or had high-profile acquisitions, including:

These companies reinvented the software developer lifecycle (SDLC) to better fit this new agile world. While some, like PagerDuty, went after clear areas like Alerting, this new way of working required a new category of tools centering on collaboration, which gave rise to some of the decade’s biggest opportunities like Atlassian, GitLab, and GitHub.

Several patterns emerge once you begin to study commonalities among companies that made it to an IPO and continue to scale effectively once in the public markets. These include a focus on a key, intractable problem for developers and companies. Common problems/themes:

• Alerting - what do I need to do when things break?
• Observability - how are my applications and network performing?
• Collaboration - how do I work across my team best?
• Infrastructure management - how can I improve managing my infrastructure?
• Data management - can I move and manage data more effectively?

‍

AI’s infra moment

A similar convergence of technologies has enabled AI software development tools. In particular,

• Computing resources like GPUs and data centers have provided the infrastructure to train large language models
• The introduction of the transformer architecture has ushered in more efficient handling of sequential data and enabled the training of larger models
• Large language models and training techniques like in-context learning, reinforcement learning, and domain-specific pre-training have made it possible to build large models for coding use cases
• AI infrastructure tooling to support the storage of data, pre-training, and intelligent search

Similar to how AWS, Containers, IaC, and other infrastructure converged to create the opportunity for DevOps + Devtools companies to emerge, the AI infrastructure stack is quickly getting to a place capable of supporting a robust ecosystem of software providers. 

GPU providers like CoreWeave, Together, Crusoe (a Felicis company), and others are effectively the new AWS. Model infrastructure and tooling like Weights + Biases (a Felicis company) and LangChain have facilitated cross-talk between ML backends. Companies offering vector databases (i.e., Felicis company Supabase as well as Pinecone and Weaviate) and RAG systems (i.e., Unstructured, Superlinked, TensorLake) have facilitated the intelligent search required to return answers from prompts. This has laid the foundation for app layer companies like RunwayML (a Felicis company), Jasper, Perplexity, and others to grow extremely quickly. 

‍

How does AI change the landscape?

An optimistic outlook of how AI will change the software building landscape includes these ideas: 

• AI will create financial efficiencies within software companies that will not be limited to DevOps organizations
• AI will automate software layer developer tooling that is more manual or workflow-related, like incident response, documentation, planning, code review, and debugging
• The first evolution will be domain/workflow-specific agents that, over time, could evolve into semi-autonomous agents responsible for parts of the SDLC. If a common agentic framework and language are developed, this could evolve into a single agent (but this is likely far out
• We are further out from end-to-end agentic software development than most investors believe

Tomasz Tunguz of Theory has posited that AI will be largely deflationary across R&D, S&M, and G&A. This position is grounded in the belief that companies should become more efficient over time once implementing AI, thus reducing the amount of required spend for each of these categories (both in labor cost replacement and increased productivity).

If this is true, then one must believe that AI will also have a market expansion effect – improving the profitability of these companies and, therefore, valuation. Companies may also benefit from the ability to place a premium price on AI-native products, also improving topline growth. 

The first iteration of AI development tools will likely follow the prior generation – focusing on a specific part of the SDLC to automate. Tasks that require human iteration will be abstracted away and automated by the agent, increasing efficiency. Our framework for tools that are susceptible to disruption is:

• Highly iterative or manual process that requires significant human input
• Low switching costs or no network effects
• Low NPS with existing users

This could diverge if agents start to learn adjacent tasks and some of these workflows become consolidated by one tool. Codium is an example of a company that is taking this approach. 

‍

‍

Where do startups have an advantage?

Startups have an opportunity to solve existing problems with a new approach. In particular, they can:

• Build an AI-native product and tech stack: They have the benefit of little tech debt and not having to retrofit AI into existing infrastructure
• Iterate on product more quickly: It’s becoming quickly apparent that AI-native companies are shipping faster than others, likely due to the rapid pace of innovation and intense competition
• Service a new issue that arises because of the adoption of ML infra: Several companies in the last wave were built to service the needs of the shift to new software development practices and infrastructure and there are likely similar opportunities in this new wave 

While each criterion above is necessary, startups need to think through how they set up systems to more quickly iterate and beat out incumbents. Their product strategy has to be rooted in an enduring competitive advantage over an incumbent—this can be through technical architecture (technical choices that enable better scale economics), building network effects into their business, or targeting different end customers.

‍

Opportunities, risks, and timing

When imagining the future of software development, we know AI has massive potential to create a wonderful state of productivity and innovation. But the big question, of course, is how any of these AI opportunities overlap with existing developer workflows and needs.

What are the most painful manual parts of the development process? Using the framework above, we can see opportunities for AI to address these challenges:

• Alerting/Incident Response: How can we improve the signal-to-noise ratio of alerting and automate the incident response process? Companies like Beeps are tackling this problem.
• Observability: How can we start to automate the remediation of the performance of applications and infrastructure? Companies like Flip.ai are building LLM-powered observability products.
• Infrastructure Management: Can we generate infrastructure from code automatically? Companies like appCD are taking compelling approaches to fixing this problem.
• Data management: Can AI push us toward on-demand intelligent data retrieval?

Further, we think there is ample opportunity for new categories to emerge including:

• Code generation: Companies like Poolside, GitHub, Magic.dev and others are developing models trained on large corpora of code. 
• Code management: As more code gets automatically generated, there are additional opportunities to better debug, secure, and perform tasks on code. Interesting companies here are Antithesis (debugging), Codium (testing), Semgrep (A Felicis company focused on code security), Sourcegraph’s Cody (A Felicis company focused on developer productivity) and several others. 
• (I)IDE: Companies like Replit, Codeium, Cursor, are intelligent integrated development environments.

The integration of artificial intelligence will become a pivotal force in reshaping the software development market, creating additional market value for incumbents and leaving opportunities for new companies to challenge the status quo. 

We are excited to see how this will play out in both the public and private markets. If you are building in this space, please reach out to us at ai@felicis.com.

A special thanks to collaborators and editors of this piece including Ian Livingstone, Steve Kamman, Corey Harrison, Astasia Myers, and Mischa Vaughn.