The Inklings of an Artificial Architectural Intelligence
A New Coding Tool Called 'Devin' Shows Elements of Design Thinking, So What's Next?
In This Post:
What’s Devin?
Why This Is a Big Deal For Architects
Devin Plans
Devin 'Thinks' Iteratively
Why This Is a Big Deal for Everyone
Immediate Effects: Software Engineers Face a Serious Crisis
Near-Term Effects: Self-Improving Design Software?
Near-Term Effects: Custom & Single-Use Design Software
Mid-Term Effects: Down with Software Giants
"We become what we behold. We shape our tools and then our tools shape us"
-Father John Culkin, SJ
Last week I wrote an unusual post about something. I didn't know what I was writing about at the time, I just had a feeling that something was going to happen with robots. Yesterday, it did: OpenAI and Figure 01 released a neural-net enabled robot capable of end-to-end tasks, which basically means that it's not programmed. It takes verbal direction and responds. In the image above, the robot is passing the man an apple after he asked for something to eat. It’s a pretty remarkable video.
But something else happened yesterday. Cognition Labs released Devin. I understand why everyone’s focused on the robot. Let's face it, robots are cool. But if you're any kind of designer, you're going to find Devin (or something like it) in your life a lot sooner than you'll see a robot.
What’s Devin?
Devin is a fully autonomous software engineer, according to its inventors. Coding assistants like Github Copilot have been around for a while, and in fact all major LLMs (GPT 4, Claude, etc) are capable of writing & editing short snippets of code. What makes Devin different is its apparent ability to handle end-to-end software projects fully autonomously. It can take an assignment like 'build me an app that can fast-forward any youtube video to the part with the dogs' and it will just make that app. It goes through the steps that a human software developer would:
Laying out a project plan.
Recruiting materials & assets (in software's case, various coding libraries and plugins).
Assembles them with code.
Writes new code as necessary.
Runs test.
Debugs itself.
Completion.
Devin is so autonomous that in demonstration videos, it even completes projects lifted directly from Upwork.1
This has huge ramifications for all of humanity, but let’s start with architects:
Why This Is a Big Deal For Architects
Devin is a big deal for architects because it shows qualities that we have historically associated with design thinking and previously believed were not the province of machine intelligence:
Devin Plans
One of the limitations about our current crop of LLMs is that they can't plan. Not really. If you ask GPT 4 to come up with a plan for planting your summer garden, it can write that plan for you. But current models can't really act as the executing agent on the plans they write. Over the past two years, various forms of 'agentic' AI software have been released, like BabyAGI and GodMode. These programs create programs capable of multi-step action by positioning one LLM as the 'planner' and then having multiple other LLMs do whatever is being planned. They've found some limited success. But you really have to know what you're doing to set up a multi-step, agentic AI. Well, the folks at Cognition clearly know what they're doing, which means the rest of us don't have to.
Squint, and you can see the foundations of an artificial architectural intelligence. Something that can't plan their own work more than 2 or 3 steps ahead of time wouldn't make a good designer of anything. A design is fundamentally a plan for making something, and the process of design requires planning onto itself. One has to lay out steps, and execute them in a particular order, to achieve design.
However, no matter how carefully you plan, you'll always run into problems. A good designer knows this, and knows how to resolve them efficiently and productively, which brings us to:
Devin 'Thinks' Iteratively
We tend to think of software as a linear algorithm: if X, then Y. We formerly believed that a machine needed to be programmed with the correct steps in order to execute anything at all. That presents a challenge when thinking about design, since design can be a non-linear process. Sometimes, you get to step 514, and realize that things aren't really working out, and you need to work backward to step 337 and take a different approach.
Devin wasn't made for architects, but such a program would be/could be essential to an artificial architectural intelligence. The ability to 'back up' on an idea when it's not working, and knowing the correct moment to do that, is not an easy skill to master. One could argue that it's not even really a skill, as much as it is 'design intuition.' Devin does something analogous when writing code. It can backtrack. Will that translate into being able to design, in the architectural sense? Who knows. What's clear is that Devin represents a meaningful step forward in abstract thinking and intelligence.
Why this is a Big Deal for Everyone
Some of Devin’s effects will be felt immediately, and will principally be confined to the software engineering sector. Other effects will be felt more downstream.
Immediate Effects: Software Engineers Face a Serious Crisis
Software development is about to get a lot, lot faster. Of course, it feels fast now. But Devin is going to dial it up to eleven in three distinct ways:
Devin will outright supplant a lot of coding work. A lot of the simpler tasks that the software industry does are now just moot. In internal testing, Devin was able to resolve 13.86% of GitHub issues found in real world open source projects.2 Not that the issues on Github represent all coding problems in the world. But, still, that represents a significant portion of at large coding problems can now be resolved without human assistance. For all the advances we've made in design software technology, architects still have to do a lot of drafting. Imagine a software debut that just picked up 1/7th of all drafting tasks in the world, effectively, instantly. It's like that.
For the coding work that still happens, it'll be a lot faster. The aforementioned tests were limited to coding problems that Devin could resolve unassisted. Meaning, Devin had to go from zero to solution entirely on its own. That doesn't account for all the problems where Devin might just resolve 90% of the coding project, and still require a human software engineer to get him (it?) over the finish line. For any of the software development projects that still require a human engineer, we can expect that they'll require a lot less of a human engineer than they once did.
For the coding work that still happens, it'll be a lot higher order. With software like Devin to resolve more of the day-to-day coding tasks, it means that any software engineers who are still employed will be able to spend their time on higher order, more complex edge cases.
Near-Term Effects: Self-Improving Design Software?
OK, so maybe you don’t care about software engineers. Fair. But this should wake you up: Devin opens the door to self-improving software. That has always been one of the more abstract tests for the presence of AGI.3 If a machine could contemplate a better version of itself, and rewrite its own code to improve itself, it would start to improve very, very quickly. Version A could imagine a Version B, and then turn itself into Version B. Version B could then, with its enhanced capabilities, imagine an even better version of itself (Version C) and build that. Devin appears to lack that self-reflection, and as far as we know, has no ability to rewrite its own code. But it seems straightforward enough to set up multiple, oppositional instances of Devin (like I did in this video). Devin A could suggest (and write) the improvements to the coding of Devin B, allowing Devin B to evolve into Devin B1. Devin B1 could then suggest (and write) the improvements to Devin A, allowing it to evolve into Devin C, and so forth.
That's terrifying. Just another step on the road to AGI, and all that that will bring. But could also have enormous ramifications for design. Just imagine if one day, you were super frustrated with Revit and asked it to do better. And it up and wrote another version of itself that worked better? Wild, right?
Near-Term Effects: Custom & Single-Use Design Software
Our lives are governed by software engineers. The global software engineering community has cooked us up some pretty cool toys, but its always been constrained by supply/demand economics. Companies don't make software unless they're pretty sure a lot of people are going to buy it. Programs like MS Office Suite, Adobe CS, and Revit all have a wide range of customizable features, which helps them maintain a wide market appeal. Those features make them cost a lot. And people won’t typically spend a lot for software unless they're sure that they're going to get a lot of use out of it. What results are 'industry-standard' applications. Sure, they may have a lot of customizable features, but they're made so that most people can do most of the things they like. Which is why no piece of software ever really does all the things you hoped it could do. Like, when using MS PowerPoint, I can move slides around in the Slide Sorter which is a quick and intuitive way of organizing my thoughts for a presentation. You know where else that would be useful? MS Word. What if I could just take all the sections of my document and move them around graphically, like index cards on a corkboard. Wouldn't that be handy? Alas, Microsoft isn't taking my calls anymore.
But what if I could make it myself? What if anyone could make any software for themselves? The supply/demand constraint is removed. There no longer has to be mass-market appeal in order for a piece of software to come to life. It could just be something that you need. It might also be something you only need once. If there's no longer a huge investment of energy to create or modify a piece of software, then why not make a piece of single-use software. As long as the cost/energy you expend in order to make the software saves you time/money on whatever it is you're trying to do, you would be inclined just to commission (from Devin or something like it) a single-use, custom software application to get the job done.
It will probably take a while for humanity to get used to this idea. Software has always been something we buy and then use. But that was because we didn't have the tools to make it ourselves. Once people start catching on that software engineering is for the masses now, expect to see an explosion of creativity, as that power is put into the hands of all the people that might be terribly creative, but just didn't know how to code. Which brings us to . .
Down with Software Giants
By far, the most exciting part is the degree to which Devin and programs like it will democratize coding. The entire human race has become dependent on software engineers to write their computer programs, in the way that they're dependent on architects for their buildings. That world has been gate-kept by coding knowledge. The democratization of coding will put extreme pressure on software giants, both inside and outside the AEC sector. Because software has been historically so complex and expensive to make, most people don't make their own. That results in a lot of market power for companies like Microsoft, Autodesk, etc. If I could run from the Bay Area to New York in under a day, I can't see any reason why I'd ever fly on an airplane, because flying sucks. If I could run that fast, then airlines would have to get their act together and figure out some way to make flying more appealing than my just running there myself. Software giants will find themselves in a similar position. The more that coding is democratized, the more they're going to have to step up their game. They're going to have to either:
Make new software that can compete with what people are making in their garages.
Improve their existing software until it can do that same.
Bring the price of their offerings down until it compares with DIY options.
Some combination of A, B, and C.
Conclusion
All told, Devin, whenever it’s released to the public, will rapidly speed up the curve of technological progress. If it doesn't, its imitators and competitors will. Self-writing, self-correcting software has the potential to be as transformative as software itself. Stay tuned.
Upwork is an online gig-economy exchange, where people can offer various coding projects that developers can undertake on an ad hoc basis.
For those unfamiliar with GitHub . . . There are tons of open-source projects that just exist out in the world, and are worked on collectively by programmers and coders worldwide. When one of them has an issue they can't resolve, they'll post it on Github as a question or specific coding problem. They're then able to crowdsource an answer, either in words or in actual coding solution.
Note: Devin is not AGI.