Dion Almaer

Software, Development, Products

AI Software Development

Stitch Prompt: A CLI for Design Variety

I love how you can have an idea and often make it real in short order. I have been exploring how to make sure that when I design my frontend I get as much variety as possible as, after all, it’s all about taste!

When seeing folks prompt for app UI, 99% of the time I see them ignoring prompting for the style they want. They rush to say what they want the app to do, which is obviously important, but giving the models more information on the style can bring you gold.

I have been collecting styles, and making it easy to pick one to explore… where the tool will fill out the right information to pass in to the models.

I wrapped this in a simple CLI, stitch-prompt, which simply takes:

I have noticed that once I get into the habit… I start to ask for a variety of styles and look at them to get a feel for what I fancy with the particular app. Sometimes my mood and the app itself has me in a minimalistic style, at other times I go for more “fun”. With the flick of a --all you get prompts for all styles to grab. It’s been delightful to put these into Stitch and see what comes out the other side:

It’s been delightful to take a series of Stitch screens and put them side by side with different styles:

And, since these are just prompts, you can fire them up with any LLM that can speak image and put them together:

We are in a world where generation is cheap, so make sure to use that fact and do a lot more curation!

We are embracing this in Stitch and hope you give it a try! We have a lot coming.

Stitch: A Tasteful Idea

Bringing Taste to Intelligence

My oldest son has been a Star Wars fan where I am more into Star Trek… with The Next Generation being the GOAT. Like many, Commander Data holds a particular spot in my heart… the age old story of Pinocchio where the non-human teaches the most about humanity.As I rewatch the episodes of ST:TNG, and see Data grow, it’s hard not to make the obvious parallels to our newest incarnation of AI. We have new LLMs from various frontier labs, and every time we fire them up it’s like booting up Data for the first time. Great intelligence sits within the weights. Mapped experience lies within. Yet it is hard to know what experience is lacking, and it’s obvious to see the importance of onboarding.

Rise of the Taste Makers

Great designers are valuable indeed. They not only have great skill, but they have taste. If we do this right, we will be able to amplify their taste.

I hire an interior designer with taste, and I enjoy the process of working with them to curate an experience that I will love in my home. I may not be able to come up with the design, but I have opinions on what I want, and I know what I like when I see it.

Every home you enter has a personal feel, something unique. I love this and want the same for many of my computing experiences. There are familiar building blocks, great for usability, but I don’t want a world where every UI looks the same. That’s boring and soulless.

I loved the early Web for its character, as strange as some of it is. The fashion evolved quickly, as we worked out what worked… and explored a new space. There is still so much to explore, and I want new AI design tools to help me, through their own skill… and through connecting me to taste makers.

Enter Stitch

One such tool caught my attention: Stitch, a product from Google Labs. The results seemed different… more diverse. I got to meet the team behind it, one that works in a group focused on the future of software development, which has some friends from the past who I found thriving. I found myself so excited about the mission that I worked to join them… and they have kindly given me that opportunity.

To pull this off we need to weave models deeply trained on great design, with a user experience that lets users wield that power. We have the seeds, with so many ideas and experiments to run and learn from.

This week we shipped a new version of Stitch that contains many performance and reliability updates, and an overhaul to the main window that gives you the freedom of an infinite canvas to play in. It’s a pleasure to use, and is a foundation we are building on.

You can see it in action with Kath’s demo that weaves together the latest Stitch with Jules, a sister project to Stitch in labs, which just had an epic week of launches as it came out of beta. Jules is an asynchronous coding agent that you can work with to massively scale your development efforts.

Taste Goes Beyond Design

There are so many areas of taste. Stitch cares about design and frontend, and Jules also cares about the taste in building great software.

We all have our own taste. A developer who picks Vue.js, does so in part because of the taste of Evan You and team. A die hard Clojure fan, follows the taste of Rich Hickey. Open Source has long been a spot for taste makers to share, and for the community to gather.

There is taste in all things code and software projects, and we can create layers that allow those who excel in accessibility to shine through more of us, as with performance, composition, and security, and on and on.

Manifesting Ideas

One of the reasons I am so very excited about the revolution we are all currently a part of, is in its potential to take away friction so that ideas can become real. What was once expensive is on the path to become so very cheap. And marrying taste with intelligence to get a sea of experiences that are delightful to use.

If you want to fight for a more utopian future vs. dystopian, we are hiring across the board. If you love building the future of computing with like minded folk, please reach out!

/fin

English will become the most popular development language in 6 years

Simon Willison wrote up his 1, 3, and 6 year AI predictions from his chat with the lovely Oxide crew. This is always a fun thing to ponder as you start a new year, especially since 2025 feels like such a futuristic number.

I found myself reflecting on this myself, and landing on a provocative thought. What if the most popular development language 6 years from now isn’t a back and forth between Python and JavaScript, or a “new” language such as Rust, but is something much more radical: English.

When I say “English”, I am using it somewhat as a short hand for natural language, so it can actually include many other languages such as Spanish and Mandarin.

This seems somewhat outlandish, right?

Maybe not so crazy given Karpathy having said this awhile back?

So, how could it come to pass?

  • Computers can now understand natural language (and other inputs that humans do, such as images and sound)
  • Computers can write code based on that understanding (including filling in the gaps)
  • Humans already use English for large parts of the development process (documentation, comments, issues, PR conversations, group chat conversations, etc etc)

Let’s dive in.

Computers are increasingly grokking us

When you look at the history of computing, we see a continuous rise in abstraction in how we are able to talk to computers. We started speaking at a very low level with punch cards, machine code, and assembly language. Only a few people had the capability and understanding on how to get computers to do things, and those things were fairly limited (yet still amazing!).

Over time, we taught the computers abilities that would allow humans to increasingly share intent at higher levels of abstractions. Why have the humans track the memory in the computer if we can make the computers do that work?

Part of the story is in building the abstractions, and the technology breakthroughs such as garbage collectors that are fast enough, or LLMs that can write code. Intertwined with this trend is the dramatic shift in raw numbers, as illustrated by Tailscale CEO Avery Pennarun in his piece on living in the numbers. The rate of change is hard to fathom. We are used to CPUs that get faster, and GPUs that can multiply matrixes increasingly quickly, and more memory, and larger faster disk, but OMG when you see the actual magnitude of the change… how computation is 200,000x faster than 20 years ago etc… it can sink in that we can expect so much more from our systems.

It’s not that we can have fewer instances handle a few more HTTP requests. Our computers can grok what we say, can see images and video, and can hear audio. How much improvement will there be in 6 years across all of these vectors? Today is the worst we have it, with repeated changes coming. Mind blowing.

The reason that we see so many applications pop up with a chat side bar is a signal that we are building bridges between the computers and the humans in natural language ways.

With development, we see this in almost all of the tools that we use. Coding assistants started with helpful auto complete, but we want to communicate deeply with the Borg connected pair programmers that we now have available 24/7. Chop chop.

Computers can write code

I mean, humans have always written code. Since the beginning of computing, we’ve created systems that translate human-written instructions from one format into another that computers can understand.

But now, we’ve evolved beyond that. We can use plain English as input and get not just code, but various other digital assets as output.

Writing code isn’t just about mastering syntax. It’s about understanding platform capabilities and technological ecosystems. LLMs possess a vast knowledge base of this information, and with deep context awareness, they can comprehend what truly matters – your code and all its dependencies.

Humans already use English

When you think about your development projects, you realize that a large amount of your time isn’t writing for loops, it’s understanding the requirements of your business and mapping them to the technology that needs to drive it.

You write requirements. You have conversations with your team in Linear and Slack and …. You have code comments. You chat with your coding assistant. We are already using English.

The difference in 6 years though, is that we will be able to switch to a spec-centric vs. code-centric way of development.

Guypo goes over this in this talk: What is AI Native Development:

Don’t think of this as a one time moment where all of a sudden all that every developer does is write specs.

It can, and will, happen gradually. This has always been the way with development.

Python rocks up and has the ability to link to C libraries and thus has access to the evolved corpus of well tested libraries that have been worked on for decades. The same can happen here. The wrapping will occur, and the lower level can evolve as makes sense. The great feature of this new approach is that the generation from English to implementation can always be re-run with the latest gains.

Compare the two paths:

Current: you open chat with your favorite coding assistant and go back and forth to get some code for certain functionality. When you are happy with it, it ends up in your codebase. You lose the context of the chat and the English intent, and you now have a base, based on the state of the art of that moment. You are left with the compiled output, so to speak.

Future: your English is the source, and as your computer systems improve, they can be regenerating new and improved implementations. It behooves you to invest in testing and validation in this world, but this is something that is actually really needed any way… we just sometimes get away without doing it.

Once we work out how to get good at this level of abstraction, more amazing things can happen. Because LLMs can understand many languages, both nature and programming, we are not truly multi-lingual. The flexibility that comes with this can be transformational, but it is also very different. Being able to fill in the gaps isn’t the same as inheritance and composition. When do we need to be more explicit vs. when is that more than makes sense to say? How do we prompt humans for more information so they can elaborate? Do we sometimes want to use pseudocode to explain something? 

Popular doesn’t mean, solely!

Notice that there are items that are not being said in this prediction?

“You don’t mean that everyone will just be writing English only, right?”

No. Most popular doesn’t mean only. There will be room for traditional code. It’s also important to remember that when we use the term “developer” we are doing a lot of work. There is a massive spectrum of people doing very different things, with very different skill sets.

There are engineers still doing very low level work, and everyone on top of those layers gets to benefit without having to do so (e.g. on top of an operating system, or using standard libraries, etc). As we wire up new platform capabilities, that wiring may be done via platform APIs are not in English.

So, while English will play a role for everyone, I think that it will best suit cases higher up the stack, with the app developers. It will be important to still understand the platforms you are building on top of, and programming languages. But this may become less important over time.

“Why did you say development language not programming language”

This is purposefully broader to represent the usage beyond the programming aspects of software development is all.

“Does this mean you think there won’t be the need for developers?”

The opposite. I think our appetite for software is insatiable, and I’m excited about how this can democratize development, and how the flexibility can allow the personalization of computing experiences for users. If there are fewer curly braces, that doesn’t mean that there isn’t any more development going on!

We have a lot to work on to make this all happen, and I will now set a calendar entry in Jan 2031 to re-read this and see how far off I am.

What are your predictions for how software development will change in 6 years?

The right thing to do, is the right thing to do.