The people making the future more livable are rarely the loudest accounts in your feed. They tend to be heads-down: shipping a release, answering a support email, fixing the thing that broke overnight. You don't hear about most of them until the work is already out in the world and quietly useful.
This is a front door to that world. Below are a handful of real builders whose work is public and checkable, what they've actually shipped, and the tools each one leans on to do it. It's the hub for our whole Builders & Makers hub collection, so once you've read the profiles you can follow the threads down into the checklists, playbooks, and toolkits that turn admiration into your own shipped thing.
Why the people building a better future work in the quiet
There's a survivorship problem with "building the future" content. The stories that travel are the launch-day fireworks and the funding announcements. The actual building is slow, unglamorous, and mostly invisible: reading docs, narrowing scope, cutting a feature you were attached to, waiting for feedback.
Grounded optimism means paying attention to that quiet part. Not because the fireworks are fake, but because the quiet part is where the durable work happens, and it's the part you can actually learn from. We're a small, independent shop, so we can't promise these are the six most important builders alive. We can promise the profiles are honest and the tools are real.
How we picked these builders
We want the curation to hold up, so here's the bar, plainly stated:
- The work is public and checkable. Every person below has shipped something you can go look at right now. No stealth-mode promises, no "trust me."
- They build in the open, or close to it. We favored people who document their process, because that's what makes them useful to learn from.
- The tools are non-vaporware. We only thread to tools that exist, ship, and have a track record you can verify.
- No pay-for-placement. Nobody paid to appear here, and nobody was told they'd be included. This is editorial curation, not advertising.
One honest caveat on the tools: we say we curated these entries, not that we ran a lab test on each one. Curation means we selected and framed them with care and dated what we say. It does not mean we benchmarked them against rivals. When you see a tool linked to our directory, read it as "worth your attention, here's the honest context," not "certified best." You can see how that process works in general on our how we curate page.
A quick disclosure: some tool entries in the directory may carry affiliate links. That never changes whether a tool makes the cut. Details are on our disclosure page.
The profiles: what they're making and why it matters
These are ordered loosely from software to hardware, not ranked. Each one is a different answer to the same question: what does it look like to build something genuinely useful without a large team or a loud megaphone?
Pieter Levels — proof that one person can ship a lot
Pieter Levels (widely known as levelsio) is the reference case for solo building. He's shipped a long line of products largely by himself, including the remote-work and travel projects Nomad List and Remote OK, and later AI image tools. What makes him instructive isn't scale; it's method. He builds in public, favors deliberately boring and stable technology, and ships fast rather than waiting for perfect.
The tools behind the work: a plain, unfashionable web stack (server-rendered code and a simple database on a single server) plus whatever hosted AI models a given product needs. The lesson threaded through his work is that shipping beats stack-chasing. We've curated the entries for the kind of no-framework web tooling and lightweight databases he favors in the directory so you can see the honest trade-offs before you adopt them.
Simon Willison — tools that make data legible
Simon Willison co-created the Django web framework and now builds open-source tooling for exploring and publishing data, most notably Datasette, along with a family of command-line tools for working with large language models (Wikipedia). His writing about how he builds is, on its own, one of the more useful running resources for practitioners.
The tools behind the work: Python and SQLite sit at the center. His whole approach is a small argument that a simple, single-file database plus readable code can take you remarkably far. We curated the SQLite and open-data tooling entries in the directory with that same honest framing: powerful for a huge range of jobs, with clear notes on where you'd outgrow them.
Julia Evans — making the confusing parts of computers approachable
Julia Evans (b0rk) builds small, focused tools and illustrated zines that demystify things most engineers find intimidating: DNS, HTTP, debugging, the shell. Projects like her interactive DNS and networking playgrounds are the kind of thing that quietly raises the competence of a whole field, one confused person at a time.
The tools behind the work: a mix of scripting languages and small self-contained web apps, plus a lot of careful editing. The pattern worth stealing is scope: each tool does one thing and explains it well. That discipline is exactly what our From Idea To Launched In A Weekend: An Honest Playbook is built around.
Andreas Kling — an independent browser, built in the open
Andreas Kling started SerenityOS as a from-scratch operating system project and later spun the Ladybird browser out of it into an independent effort to build a new, genuinely independent web browser engine — a famously hard thing to attempt. It's organized as a US 501(c)(3) non-profit, the Ladybird Browser Initiative, developed in public and funded by sponsorships and donations rather than advertising deals (Ladybird).
The tools behind the work: C++ and a large, patient open-source community. This is the long-horizon end of building: a project measured in years, not weekends. We point to hard, foundational efforts like this in Robotics, Space & Hard Tech, because "quietly building the future" sometimes means signing up for a decade of unglamorous work.
Andrew "bunnie" Huang — open hardware you can actually inspect
Andrew Huang is a hardware engineer and author known for open-hardware work and for arguing, in practice, that you should be able to understand and trust the devices you own. His projects span open-source hardware designs like the Novena open laptop and security-focused platforms like Precursor, built to be inspectable rather than sealed (Wikipedia).
The tools behind the work: electronics design tools, open documentation, and a commitment to publishing schematics. Hardware is slower and less forgiving than software, and his work is a good honest reminder that the feedback loop can be long. If hardware is your direction, our discipline-split Maker Toolkits By Discipline (Dated, Honestly Framed) separates the design, dev, and hardware kits so you're not stuck reading advice meant for a different craft.
A grounded note on all five: none of these people are going to single-handedly "change the world," and framing them that way would do them a disservice. What they share is more modest and more repeatable — a habit of shipping real, inspectable things and being honest about the trade-offs.
The tools behind the work, threaded honestly
Rather than hand you a giant list, we've threaded each maker to the kind of tooling they actually rely on inside the directory, where every entry is dated and framed with its real trade-offs. A few patterns are worth calling out directly:
| Builder | Kind of work | Tooling pattern | Where to dig in |
|---|---|---|---|
| Pieter Levels | Solo web/AI products | Boring, stable web stack; ship first | directory |
| Simon Willison | Data + LLM tooling | Python + single-file SQLite | directory |
| Julia Evans | Explanatory dev tools | Small scripts, tight scope | idea-to-launched playbook |
| Andreas Kling | Independent browser engine | C++, open community, long horizon | hard tech |
| bunnie Huang | Open hardware | Inspectable design, published schematics | maker toolkits |
The through-line: none of these people chose their tools to look impressive. They chose tools that let them ship and keep shipping. That's the honest signal to copy.
Patterns: what the best builders have in common
Read enough of these stories and the same handful of habits keep surfacing:
- They cut scope early and often. The shipped thing is almost always smaller than the first idea. Deciding what not to build is most of the job — which is exactly why we made A Founder's 'Is This Worth Building?' Checklist.
- They pick boring, stable tools on purpose. Novelty is a tax you pay in bugs and rewrites. The durable builders spend their novelty budget on the product, not the stack.
- They build in the open. Public work invites feedback earlier and builds trust faster. It also keeps you honest.
- They're candid about misses. The honest ones will tell you what didn't work. We lean into that in How Indie Builders Ship Optimistic Products (3 Short Profiles), where the trade-offs and the misses are the point.
- They finish. The whole thing is finishing. A shipped small thing beats an unshipped grand one every time.
None of these is a secret. That's rather the point: the future isn't being built by people with access you don't have. It's being built by people who kept their scope small and kept going.
Start building: the checklist, the playbook, and the starter stack
Admiring builders is pleasant. Becoming one is the actual goal. If any of the profiles above made your hands itch, here's the honest on-ramp, in order:
- Pressure-test the idea with A Founder's 'Is This Worth Building?' Checklist before you sink weeks into it.
- Pick a weekend-sized first version using From Idea To Launched In A Weekend: An Honest Playbook, which is honest about what a weekend can and can't deliver.
- Grab a minimal stack from The 'Now Go Build It' Starter Stack, where the disclosed pointers are kept clearly separate from the curation.
- Find your people through Communities For Optimistic Builders (Curated), because building alone is harder than it needs to be.
In Plain English
What this is: an honest, hand-picked front door to real people building useful things, threaded to the tools they actually use and to the rest of our Builders & Makers guides.
Who it helps: anyone who wants proof that ordinary, heads-down builders make the future — and wants a concrete on-ramp instead of a highlight reel.
When to use it: when you're tired of hype accounts and want checkable examples plus a clear next step toward shipping your own thing.
What to do next: skim the profiles, follow one thread that fits your craft into the directory, and then start the four-step on-ramp above with the checklist.
Where To Go Next
Each of these goes one level deeper into the work of building:
- A Founder's 'Is This Worth Building?' Checklist — a reusable demand-moat-honesty test before you commit weeks.
- How Indie Builders Ship Optimistic Products (3 Short Profiles) — three honest profiles, including the misses.
- Maker Toolkits By Discipline (Dated, Honestly Framed) — design, dev, and hardware kits with clear "when to skip" notes.
- From Idea To Launched In A Weekend: An Honest Playbook — a scope-tight plan for shipping something small and real.
- The 'Now Go Build It' Starter Stack — a minimal, job-to-be-done stack with disclosed pointers.
- Communities For Optimistic Builders (Curated) — a vetted shortlist of where optimistic builders find their people.
Explore Builders: browse the maker profiles and toolkits at the Builders & Makers hub, then pick the one thread that fits what you want to make and follow it all the way to shipped.