What Developers Are Actually Building for Themselves in the LLM Era

A recent Ask HN thread posed a deceptively simple question: what tools have you built for yourself since AI arrived? The 44-comment thread is worth reading in full — not for viral demos, but for the unglamorous, genuinely useful tooling that working developers are assembling for their own workflows. Several clear patterns emerge.

Agent-Aware Tooling: Making Your Tools Visible to the Agent

One of the sharpest ideas in the thread comes from the builder of SDocs, a CLI-driven Markdown reader that privately renders documentation in the browser. What makes it notable is how it integrates with agents: on install, it asks permission to update your base agent prompt files — ~/.codex/AGENTS.md, ~/.Claude/CLAUDE.md — with instructions on how to invoke the tool.

The result: every agent session you start already knows SDocs exists and how to use it. In practice that means issuing something like "Hey Claude, sdoc me a list of all my open MRs" and having the agent drive the tool automatically. It's a small architectural idea with large implications — if your personal tools are described in agent context files, the agent can compose them without explicit prompting every time.

This is a pattern worth stealing. Agent context files (AGENTS.md, CLAUDE.md, and their equivalents) are increasingly the right place to document personal tooling, not just project conventions.

Personal Recall Infrastructure

Several builders are solving the same underlying problem: search engines and LLMs answer questions about the world, but neither reliably answers "what did I read last Tuesday?"

Hister (GitHub) is a self-hosted full-text indexer that automatically saves every page your browser renders. It offers a flexible web and terminal search interface with offline previews and a detailed query language. Its author is explicit about scope: it handles recall searches (retrieving content you've already visited) well, but falls short on discovery searches for now. That's an honest and useful distinction — Hister is personal memory infrastructure, not a search engine replacement.

A simpler version of the same impulse: a plaintext bookmarks Chrome extension that saves links to a local Markdown file and syncs to Dynalist, Workflowy, or GitHub Gist with import/export between them — plain text all the way down, no proprietary lock-in.

Voice as a First-Class Input

One developer built a voice memo app that goes a step beyond Apple's: after recording, it pushes transcripts to iCloud, runs Claude Code over them, and surfaces structured notes back in the same app. The use case is a long walk — stream of consciousness for an hour — and structured output waiting when you're back at the desk.

The app is ~20,000 lines including tests, described as "vibe-coded" with some real engineering still needed for bugs, but with UX that already works well. It's a reminder that "vibe-coded" and "production-quality" aren't mutually exclusive when the developer is also the primary user and can tolerate rough edges.

Security and Isolation: Sandboxing Everything

A striking number of entries involve running AI agents or browsers inside containers. Three separate tools address this:

• Foxcage: runs Firefox inside Podman to isolate it from the host, with features not available in existing solutions.
• claude-sandbox: runs Claude inside Podman with a proxy layer specifically for securing credentials.
• A multi-backend sandbox tool that creates isolation environments across Docker, Podman, OrbStack, Seatbelt, Tart, containerd, Kata, and Firecracker, then sets up an agent (Claude, Codex, Gemini, Aider, or OpenCode) inside it with maximum permissiveness — no prompts for routine operations like sed.

The common thread: developers who are running AI agents with real filesystem and shell access want container-level isolation, not just trust-the-model guardrails. This is mature security thinking — threat-model the agent like you'd threat-model any external process.

Also worth noting: an email sanitization tool in progress that applies allow/deny policies to HTML, SVG, calendar, and vCard parts; cleans URLs; fetches remote content at delivery time (eliminating tracking pixels); and handles PGP/SMIME auto-encryption and decryption. Not AI-specific, but exactly the kind of careful, specification-driven tool that benefits from LLM-assisted implementation.

In-Context AI: The Browser as a Shell

A Chrome extension that adds a tiny "what's this" popup to any selected text — sending the selection to an LLM and displaying the answer inline — sounds trivial but solves a real friction point. The author built it primarily to decode the dense abbreviations and jargon common on HN, but the same extension can modify selected text in-place. It's a paper cut fix for a specific reading context, exactly the kind of tool that only gets built when the cost of building is near zero.

Domain Tools That Would Never Have Been Built Before

Not everything here is infrastructure. Several entries are tightly scoped domain tools:

• Hex Flex: views and diffs Intel Hex files, aimed at firmware developers.
• A genealogy tool with GEDCOM import.
• A playlist and library manager for DJ use.
• A music collaboration sync tool for Ableton projects.
• A calendar change notifier that watches .ics URLs and emails diffs.
• A work time tracker rendered as a 1-pixel line at the edge of the monitor that fills based on current activity.

These tools share a property: the development cost before LLMs would have exceeded the value for any single user. Now the calculation inverts — a firmware developer can have a polished hex file viewer; a DJ can have a custom library tool.

The Process Lesson

One developer who's used AI to build a club website, a Stripe ticketing system with QR door scanning, an Instagram media ingestion pipeline, film archiving scripts, and more offers the most concrete process advice in the thread:

"Make the change small, be clear about what it is supposed to do, check the assumptions before coding, use tests/logging/manual checks as evidence, and don't merge anything I can't review and explain myself."

This is the discipline that separates developers using AI as a force multiplier from those drowning in AI-generated debt. The tools in this thread are small, purposeful, and owned by their authors — not cargo-culted from a prompt.

The thread is a snapshot of a specific moment: LLM capability has crossed the threshold where personal tooling is worth building again, but the best builders are still the ones who understand what they're building. The category of "software I wrote entirely for myself" is quietly expanding, and the patterns — agent context integration, personal recall infrastructure, container-level isolation — are worth paying attention to.