For years my ideas lived in Obsidian, and for a while that worked.
Then I started tending the tool instead of the ideas. Plugins piled up. I rebuilt my folder structure twice, then wrote templates for my templates. Whole evenings went into designing a system for capturing ideas while the ideas themselves sat untouched. Half-thoughts lived next to real projects, to-dos hid in daily notes, and nothing told me what to work on next.
The Obsidian crowd has a name for this. Sébastien Dubois, who writes a lot about the app, puts it bluntly: "Endless tool customization is usually procrastination in disguise." (source)
So I did what any procrastinating developer would do and reached for the ultimate form of procrastination: I built my own tool.
Five weeks later I open it every morning. It's called Foundry. It fits my day exactly, and building it cost me somewhere between 10 and 20 hours for now. It's still not completely finished but that's the fun of personal projects. They never are finished and you can tweak them however and whenever you want. With the arrival of agentic workflows this way of building your own tools is the easiest it has ever been. Here's how that became possible and what I picked up along the way. By the end I hope you'll want one of your own.
The best software is the software you build for yourself
Robin Sloan once wrote about a tiny messaging app he made for his family of four. It had no growth plan or business model. It only had to work for the four of them. He called himself "the programming equivalent of a home cook." (source)
That framing stuck with me because it names the one quality off-the-shelf software lacks. Companies design those tools for millions of people, so they end up shaped like an average of millions of people. You adjust your habits to the app, or you spend your evenings adjusting the app with plugins and settings. The adjusting never really stops.
Software you build for yourself fits from day one. Your requirements are the only ones it has.
The catch has always been cost. A home-cooked app used to take real programming skill and a lot of evenings. I enjoy working on personal projects. But I also enjoy a bunch of other activities. Spending time with my family and also maintaining other hobbies and relationships sometimes take precedent over working on personal projects.
Why now
That cost has collapsed.
Back in 2023, Geoffrey Litt predicted that "all computer users may soon have the ability to author small bits of code" with the help of LLMs. (source) A year later Simon Willison spent a week building little tools with Claude and reported that most of them "took less than five minutes to build." (source)
Foundry is a bigger version of the same thing. I'm a professional developer, so I had a head start. AI still changed the economics for me:
- First commit: 29 September 2026
- Since then: 135 commits, 51 merged pull requests, 5 written design decisions
- My time: roughly 10–20 hours of hands-on work
- My bill: free-tier hosting and database, the cheapest tier of my AI subscription, and an optional domain
Those hours went into issues, decisions and reviews. The agent did the building while I got on with my day, and it wrote well over 90% of the code. My job was deciding what should exist.
I also took this project to see how much I could get done without actually getting knee deep in the code. This made sure I had a personal goal for this project as well. Get better at agentic coding and seeing what the pro's and con's of this way of working is.
Your experience is the multiplier
This part surprised me. Years of experience made the whole thing easier, because I barely had to learn anything new.
The hardest part was knowing exactly what I wanted and saying it precisely. Experience pays off right there. You already have the vocabulary for patterns, packages and trade-offs, so you can ask the agent to "store this in localStorage, the same way the Done section does" where a beginner would type "make it remember." You notice when a proposed design will hurt in three weeks. The agent handles the details you leave open, and you make sure the right ones are open.
A junior developer can build personal software with AI too. Someone with years behind them steers it with almost no friction, since the words are already there.
What Foundry is
Foundry is a private workspace with exactly one user, me. A few ideas sit at its core:
- Ideas are rough thoughts. Foundry literally calls them Brainfarts, because that's what they are. They belong to no project until I decide they're worth one.
- Promotion turns one or more ideas into a real project with tickets and a log.
- Todos are small, projectless chores. I tick them off and throw them away.
- Today shows one thing to focus on and what comes after it.

Obsidian never gave me that line between "a thought I had" and "something I'm actually doing." Foundry is built around it.
Grow it by using it
The most important lesson came from using Foundry while I built it. As the only user, I hear about problems the moment they happen. Surveys and analytics dashboards don't come into it. I open the app, something annoys me, and that annoyance becomes the next change.
My loop looks like this:
Here's how that played out in practice.
I built a feature and deleted it four days later. On 13 October I added project documents, rich pages inside each project that worked like a mini wiki. On 17 October I ripped them out. I had never opened one. Each project's log already held everything I needed. A product with a million users keeps a feature like that forever, because somebody depends on it. Mine had one user who didn't care, so it went.
Todos showed up when I needed them. Foundry launched without to-dos, and I kept my small daily chores in Obsidian. Every morning I checked two places. Eventually I added Todos as their own simple record with no project or ticket attached. You tick one off or throw it away. Living without them first is what told me how they should work.
Paused projects got out of my way. I kept scrolling past projects I had paused. Now Paused, Completed and Archived fold away by default, and Foundry remembers how I left each group. A change that small would never make a product roadmap. It's also one of the reasons the app feels like mine.
I planned none of these. My real requirements only showed up once I used the thing every day.
How I work with the agent
Every change starts in Foundry itself. When something bugs me, I jot it down there as an idea. Later I take that idea into a session with my agent and run the grill-me skill from Matt Pocock's skills repo. It interviews me about the change until we both know exactly what I want. The outcome of that grilling becomes one or more GitHub issues, and I work through them one by one with an agent.
Foundry tickets or GitHub issues
That workflow raises an obvious question. Foundry has its own tickets, so why do Foundry's own changes live in GitHub?
Every project in Foundry picks one work source, and it picks it for good. Some projects keep their work as Foundry tickets. Others connect a single GitHub repository, and their issues become the work. Mixing the two in one project would give every piece of work two identities, two sets of states and two orderings to keep in sync, so I wrote that rule down as one of the first design decisions.
Software projects, Foundry included, use GitHub. Issues sit next to the code there, and the agent already knows how to read them, branch from them and close them with a pull request. Everything else, like this article or a board game night, runs on Foundry tickets.
A GitHub-backed project still shows up in Foundry like any other. Foundry reads its issues live through a small read-only proxy (more on that under Lessons) and never copies them. I can make an issue the project's next action or pick it as today's focus, and the work itself stays where the agent can reach it. One place to look each morning, while each kind of work lives where it belongs.
The issue is where experience shows. Here's a trimmed one about open tickets on a project I pause or finish:
## Decisions
- Leaving Active with open work: choosing Completed or Archived on a
project that still has Open or In progress tickets opens a dialog
showing the count, with "Leave them as they are", "Mark all Done"
and "Cancel". Paused and Planned change instantly.
- Next action: kept on Paused and Planned; cleared on Completed and Archived.
## Scope
`ProjectStatusControl.tsx`, `set_project_status` (clear the next action
on Completed/Archived, optionally mark open tickets Done in one transaction)
## Acceptance criteria
- [ ] "Cancel" leaves the status unchanged.
- [ ] "Mark all Done" sets every open ticket to Done together with the status change.
There's no code in it. Every line settles something the agent would otherwise guess at, right down to which files to touch and the requirement for a single transaction. Write issues like that and the pull request mostly writes itself.
The repo also gives the agent standing instructions in an AGENTS.md file, so every session starts from the same context:
### Domain docs
This is a single-context repository. Read root `CONTEXT.md` and relevant
ADRs under `docs/adr/` when they exist.
### Design
Follow `docs/design.md` when building or changing the UI.
Two files carry a lot of weight here. CONTEXT.md is a glossary of Foundry's own language (Brainfart, Promotion, Discard), which keeps the agent using my words. Short ADRs (architecture decision records) explain why things are the way they are. One of them records why project documents went away, so a future session won't helpfully bring them back.
Lessons
Scope it small. My first version was a tiny MVP on purpose, so I could start using it as fast as possible. A personal tool only has to be useful tomorrow morning. Anything you add before you've used the app is a guess.
Let use decide what to build. Real requirements show up while you're using the thing. Write down the friction when you feel it and fix it then. Delete whatever you stop using. Nobody will complain.
You're still the security team. The AI writes the code. Caring about your data stays your job. Simon Willison draws the line well: "Vibe coding is not the same thing as writing code with the help of LLMs." (source) If your tool holds anything that matters, read what the AI writes and keep secrets out of the repo. Give it the least access it needs. Foundry reads my GitHub issues through a small server-side proxy with a read-only token. The browser never holds a key, and even if I get something wrong, the app has no way to change anything on GitHub.
Isn't this just over-optimizing with extra steps? Fair question, coming from someone who fled Obsidian tinkering. Tuning a general-purpose tool goes on forever, because you keep bending something designed for someone else. Building your own means writing down what you want, and once it fits, you stop. Dubois's advice is to change a tool only after you hit a real problem. Foundry grows exactly that way. A real annoyance turns into a small PR, and I get back to work.
Don't worry about whether it lasts. People ask what happens in a year, when dependencies age or I lose interest. Honestly, it doesn't matter. Foundry will live as long as it's useful to me. With one user, nobody gets let down when it stops. Whatever happens to the app, what I learned building it comes with me to the next project.
Build something just for you
For most of computing history, you picked software off a shelf. If nothing on the shelf fit, you adapted.
Today you can describe what you want and have it built. Start small, use it every day, and a few evenings later you'll have a tool shaped exactly around you.
If you're a developer, you're the best-placed person in history to do it. You already speak the language the agent needs.
It has never been a better time to build software for an audience of one.
What would you build?



Top comments (0)