Can We Create Software Now From Just Prompts?
The current state of AI-coding tools, especially the cool new ones
Many software investors are asking whether AI-powered coding could dramatically shorten development cycles or even replace the need for human coders. This could mean quicker time-to-market, more rapid introduction of new features, and potentially a major shift in the basis of competition.
And while the current state of the art is impressive, as you’ll see in the next section, we are a long way from a series of prompts being enough to write enterprise grade software. What we’re seeing right now is productivity improvement of around 10% to 40%. It’s augmentation not full automation, and it will likely be quite a while before full automation becomes possible.
But, let’s start with something cool…
Building an App From a Prompt
One of the most exciting developments in the world of coding AI is the emergence of tools like Lovable.ai and Bolt. These platforms can build entire web applications very quickly—generating a full repository rather than a single monolithic file. I was able to create a relatively simple game, Tetris but with five block pieces instead of four block, using only prompts. Literally, my initial prompt was “Create a Tetris game but the pieces are 5 squares instead of 4” and it required only a few tweaks (all done with prompts) to get to a game. See the screenshot below.
However, after a couple of hours of trying, I couldn’t get it to deploy to a place where you could play it. So, a bit disappointing in the end.
What is impressive, though, is that it created a whole file structure:
You can see that it produced a full set of individual files, which is the proper way to code a full app.
As a way to create prototypes and test concepts, these new tools are incredible. However, these tools are built on a very specific stack. They cannot just be dropped into an existing application and start manipulating the code.
But What About Coding Co-pilots?
We should compare these new tools with the more established coding assistants like GitHub Copilot, Codeium, or Amazon CodeWhisperer. These tools are typically integrated into your development environment and are designed to generate code within the context of a single file. They are great at suggesting small changes, refactoring code, or even drafting new functions based on what you’ve already written. Their strength lies in handling simpler tasks— writing a quick function, drafting unit tests, or documenting existing code. Bug fixing can be hit or miss, depending on the type of error.
Note that some of the productivity comes from steps that are not writing code! Documenting code and creating simple tests are tasks that developers hate doing. Making those tasks easier creates extra productivity gains because developers often drag their feet while doing these tasks. This all adds up to real and sustained productivity gains that companies are taking advantage of!
However, this file-by-file approach means that these assistants struggle when it comes to implementing more complex, cross-cutting changes that span multiple files and modules. They don’t have the full view of a project’s architecture. When you need to add a new feature that requires coordinated updates across controllers, services, and data models, the context window for these tools isn’t big enough. So, they are great helps for individual tasks but not able to implement full features with a simple prompt.
What The Future Could Hold
So, where does that leave us? We are a long way from prompt-based tools that can replace humans. We should expect that tools will continue to augment developers for at least the medium term. I’d expect software firms to start increasing their expectations of how fast new features can be built, but I think without a big breakthrough, we won’t get too much higher than the productivity gains we’re seeing today.
As mentioned in the previous section, the biggest limitation is context window size. It’s worth mentioning that there are some teams doing research on greatly improving the size of these windows or even creating “infinite” context windows. Now set aside for the moment whether this is possible (maybe I’ll cover it in a future post if there’s a big development).
Imagine a bot that can fully ingest a coding project, all the files, the schemas for all the APIs, etc. In that situation, maybe you could create a bot that could add new software features based on a prompt. This is probably many years away, but it could enable all kinds of new business models.
SaaS companies could offer unprecedented degrees of customization for their clients. Customers could suggest any kind of form that they need, and the software could process it. They could enable companies to create a custom interface for their employees. Custom reports or analytics could be generated using code based on prompts. It would mean that several B2B software business models would shift dramatically while they create substantially more value for their customers.
Conclusion
So, what does all of this mean for investors:
There are tools that can generate working software with prompts, but they only really work for prototyping. You are likely to see many cool videos, but the tools have real limits.
Existing coding tools can improve developer productivity 10-40%, which should improve the speed of software development across the board. Make sure your portfolio companies are using these!
However, these tools are limited to making changes to individual files and aren’t able to understand the full context of a project. So, don’t assume these tools will reduce your development cost to zero.
If it becomes possible to build LLMs with “infinite” context that can ingest a full project and generate new products and features based on prompts, then that will have a profound effect on the software business. However, that possibility is likely a decade away.
But, the world is moving quickly, so it’s important for investors to keep on eye on how these tools are developing and ensure that their portfolio companies are quick to adopt the next generation of tools.