BlogProduct

What's worth building?

Lake Faith

In an era when you can build everything, why would you maintain anything? Instead of building or buying a tool that helps with most of your jobs, but maybe not perfectly, why not build tools for each different task? Scrap them when you’re done; build the next one.

"Disposable software" is the name that's stuck for this process. Programs built to solve one problem or help with one task, then thrown away. There’s no need to think about edge cases or how they’ll be maintained, because they were never intended for that. They’re the software equivalent of a jig: a guide woodworkers build for a single job.

The idea of “disposable software” is older than the vibe-coding boom, but the name only drifted into use around 2025 and 2026. It most likely originates from Andrej Karpathy, an OpenAI co-founder and former head of AI at Tesla. In his 2025 year in review, he described AI-written code as "free, ephemeral, malleable, discardable after single use." Thanks to AI, software that was never worth building suddenly is, as long as you don't plan to keep it. Earlier this year, developer Chris Gregori described the shift as “moving from SaaS to scratchpads.”

The concept of single-use software has been around even longer. In 2004, Clay Shirky, a writer on internet culture who taught at NYU's Interactive Telecommunications Program, wrote about "situated software," small tools built for one group of people rather than for everyone, and pointed out that most software only ever gets a few users for a short time. In 2020, Robin Sloan, a writer, printer, and home-developer, described building a messaging app for his family as the coding equivalent of a home-cooked meal. In 2024, designer and anthropologist Maggie Appleton, now a staff research engineer at GitHub Next, predicted a golden age of home-cooked software, made by a new kind of "barefoot developer." Gregori points out that this kind of software resembles how Excel was originally used; “You didn't open a spreadsheet to build a permanent, multi-year database; you used it as a scratchpad to reason through a problem, calculate the results, and move on,” he writes.

They may not have all been disposable; Sloan’s family is still using the app six years later, but none of them was built to be scalable, shared, or shipped.

Today, the conversation about disposable software is split three ways. Enthusiasts say the time between wanting a tool and having one has dropped from weeks to hours, so you should build freely. Pragmatists want a durable core of logic that matters, with a disposable layer around it that you regenerate whenever you need to. Skeptics point out that code being cheap doesn't make software cheap. Maintenance is still expensive, so what happens when you decide to turn your jig into something you might ship?

Opinions differ across the team, but we’re using disposable software more and more internally. We’ve been using tldraw office to build a lot of our jigs. Let’s explore the three main arguments before we get into some of our thinking.

What AI changed

Even when AI was in its infancy, it could build the quick little tools you didn’t want to do by hand - or didn’t care about enough to polish. Simon Willison, co-creator of the Django web framework, has made more than 150 small, single-file tools over about two years, nearly all written by LLMs. Each one would have been a whole afternoon's work before.

The audience for this kind of software has grown too. Kevin Roose, then a technology columnist at The New York Times and not a developer, started calling his vibe-coded apps "software for one." People who never thought of themselves as programmers are making small, personal, disposable tools, the way people have always made spreadsheets.

Within tldraw, this looks like our GTM team vibe-coding tools to automate research tasks, track metrics, and fix small things we'd previously have had to ask the devs to do. Spencer, our US sales lead, has taken the lead and is now sharing his wisdom on how to get green dots into the repo.

Non-technical guide to getting your green dots on GitHub

How it's changing the way we work

Coding may no longer be the barrier to entry for creating disposable software, but planning still is.

The standard advice for working with agents is to plan first: write the spec, then let the agent build it. But as Max, an engineer on our team, put it at our recent engineering summit, "the first shot of you trying to articulate your ideas is rarely going to be what you actually care about." Disposable software changes how we deal with that. Because a jig is so time-inexpensive, we don't have to get the plan right before we build. We build a rough version, use it, and let it show us what we actually meant. Often the first jig isn't the tool at all, but a jig for working out what the tool should be. Then we throw it away and build the one we need. In Max's words: "planning is also building and experimenting."

Disposable tools have also become shared reference points. Much of the disposable software we make is for explaining more than doing. For example, a diagram of how one part of the system works, built for a single code review, or a board of before-and-after screenshots for one pull request. These give everyone involved the same concrete thing to point at. Researchers call this a boundary object: a shared artifact that people with different contexts can all read. While these were used before, now you can make one for every discussion that would otherwise go around in circles. Appleton has written about why agents need thicker interfaces like this rather than more chat boxes.

There are some drawbacks. A low barrier to entry can come with higher risks. A prompt that a year ago meant "add this field across my codebase" now means "build me a whole terminal UI," which you come back to eleven hours later. We’re in the golden age of slopforks. It’s never been easier to make things you don’t understand. That doesn’t mean you should make less. But rather, use those cheap tools to keep yourself in the loop on the decisions that matter.

Our disposable software factory

We make a lot of disposable software for ourselves, and most of it lives on a canvas in tldraw office, our local, file-based desktop app. That wasn’t the intention for tldraw office, but it turns out it makes a great foundation for disposable software.

If the team runs into friction, you can point an agent at tldraw office and start building a tool or system to unblock it.

Coding agents like Claude Code and Codex can read and edit files, run one-off code against the canvas, or leave behind scripts that turn a file into its own small app.

In practice, what we build falls into two groups: jigs and small internal tools.

The jigs are built to explore one specific part of one specific project. We use them while we work something out, then throw them away. For example:

  • Tuning tools — while working on animations, Max built a slider to try different speeds, so she could feel the difference rather than guess at numbers in the code.
  • PR explainers — when a pull request about "deep links" turned out to use the term for two different things, the review came with a side-by-side diagram showing where the meanings clashed.
  • Screenshot boards — "can you render out all the new UI, take screenshots, and put them in the same tldraw office doc?" One prompt, and a UI change gets a before/after board that the whole team can comment on.

Some jigs became less disposable than others. A presentation mode we built in tldraw office is now our go-to slide deck. Others we never used again.

But they're worth it because they were low-cost and because a canvas is a good place to make them. Everyone, agents included, can point at the same thing.

So what's worth making?

If code is discardable after single use, the question isn't whether to build something. It's what the thing is for. The best disposable is a tool that helps you understand, decide or explain something faster than you could without it, and that you can drop once it's done that job. It’s not just a sloppier version of existing software.

We’d love to hear about the jigs you’ve been making (or doing). Get in touch with us on our Discord or follow us on X. If you'd like to put a canvas like this in your own product, check out our docs or starter kits.

Trusted by these companies

  • AlAI
  • bigpi
  • CADChat
  • Google
  • Replit
  • BlackRock
  • Loveable
  • ClickUp
  • Autodesk
  • Google Stitch
  • Luma
  • Runway
  • SchoolAI
  • Honeycomb
  • Padlet
  • Genio
  • JAM
  • Mobbin
  • Brisk
  • Aries
  • Dirac