Sign up to try The Blind Computer. Join the early access list.

The Blind Computer

I built The Blind Computer to make my mother's life easier. Now, I'm improving it.

June 3, 2026

My mother has been totally blind since 1988. In the decades since, she has built businesses, raised a family, and run circles around people who can see perfectly well. Blindness never made her less capable. The world simply kept building its tools for eyes and forgetting to leave a door open for her.

So I built her a door. The Blind Computer started as one stubborn idea: my mom should be able to pick up a phone, talk to a computer, and have it talk back — naturally, with no screen, no menus, nothing to memorize. Ask it questions. Have it read to her. Help her run her day and her work. Treat the most powerful AI on the planet the way a sighted person treats a search bar.

It worked. It genuinely made her life easier. That's not a marketing line — it's the single most important fact in this whole story, and I'll come back to why.

This post is about what that first phase proved, what it surfaced, and why I'm now taking everything I learned and building the version that's ready for the world. I'm writing it openly — including the rough parts — because transparency is exactly how a professional earns the trust to handle someone's data. And handling your data safely is the entire point of what comes next.

Who's building this

I've spent about ten years as a freelance software developer, including years of contract work on digital projects for large consumer brands — the kind of work with real budgets, real deadlines, and real consequences when something breaks in front of customers.

I mention that for one reason: I know what production-grade software is supposed to demand of the person building it. That background is precisely why I run the kind of disciplined, clearly-labeled testing process I'm about to describe — and why I treat your data the way I'd expect mine to be treated. The lessons in this post aren't the story of someone learning that discipline the hard way. They're the story of that discipline doing its job.

What changed in how we build software

For most of my career, building software meant writing every line by hand. It was slow, and that slowness was secretly a safeguard: you couldn't ship something you didn't understand, because understanding it was the only way to build it.

Then came agentic AI code generation — systems that don't just autocomplete a line but plan, write whole features, and wire things together on their own. Used well, it's the biggest leap in productivity our field has ever seen. A solo builder can now move like a small team.

Here's the part most of the industry hasn't fully reckoned with yet, and where my experience actually matters: when an AI writes the code, the old safeguard disappears. Understanding is no longer automatic — you have to go earn it on purpose. The single most important skill in this new era isn't prompting the AI. It's knowing, with an engineer's instinct, exactly where its output needs to be checked, hardened, and refused. That's the discipline I've spent a decade developing, and it's the discipline a huge amount of AI-built software shipping right now is missing.

The real danger — and why it's a discipline, not a disaster

There's a seductive assumption baked into agentic development: if it runs, it's done.

It isn't. "It runs," "it's correct," and "it's safe enough for a vulnerable person to depend on" are three completely different claims. An AI agent is brilliant, tireless, and has no skin in the game. It will confidently produce code that looks right and works in the happy path you happened to test — while quietly skipping the questions a seasoned engineer asks by reflex: What happens when a user does the unexpected? Where exactly does money get spent, and what stops it from being spent by the wrong person? If this could leak data, whose, and how would we even know?

For someone shipping a weekend project, skipping those questions is a shrug. For a production system that real people depend on — one handling personal conversations and spending real money on every call — those questions are the job. The difference between a professional and someone just shipping whatever the AI emits is that the professional treats finding those problems as the work itself.

Which is exactly what the first phase of The Blind Computer was built to do.

The first phase was always a test — and it was labeled as one

The first public version of The Blind Computer was never positioned as a finished product. It was a deliberate, controlled testing environment. It was built first and foremost for one person — my mother — and then opened to a small group of volunteers, every one of whom was told plainly, up front, that this was an in-development system that might have rough edges, and asked to use it on that basis.

That informed-consent framing isn't an afterthought. It's a professional safeguard. Nobody walked into the experience without knowing what it was. And a labeled test environment exists for exactly one reason: to surface problems where they can be caught and fixed, before anyone is relying on the system as finished, and before it's handling anything it shouldn't. That's not the safety net failing. That's the safety net working.

Here's what the test surfaced.

What the test surfaced — a post-mortem

A post-mortem is what engineers write after testing reveals something, so it can't slip through again. Here's mine.

It talked over my mother. The most human failure of all: the system would start speaking and interrupt her mid-sentence, and she couldn't reliably stop it or end the conversation on her terms. For a tool whose entire purpose is independence, control has to sit with the user, always. The test made that requirement concrete in a way no spec ever could.

The speech itself was rough. Awkward phrasing and stumbles — small on paper, large when conversation is the entire interface and there's no screen to fall back on.

Email broke the way real work breaks. Creating emails, getting email addresses right, and reading incoming emails back — all of it was unreliable. For a sighted user that's an annoyance. For a blind entrepreneur for whom email is the office, it's a barrier.

The document toolchain failed where it mattered most. My mother relies heavily on creating professional PDFs for her work. That toolchain didn't hold up. Combine broken PDF generation with unreliable email, and the core entrepreneurial use cases — the reason a working blind professional would reach for this every day — became a non-starter. The test didn't just find bugs; it mapped precisely which capabilities have to be rock-solid before they can be trusted with real work.

Unknown security questions. When an AI assembles a system that touches personal data, you cannot simply assume it's airtight — and a professional doesn't. In a controlled test, with informed participants and nothing positioned as production-ready, treating "what might leak, and how would I know?" as the number-one thing to hunt down is the correct order of operations. You find these things in a sandbox, on purpose, so they never happen in production. That's not a risk we took with your data — it's the discipline that ensures we never will.

The billing guardrail was in the wrong place — and the test caught it. The Blind Computer costs real money to run; every call spends money behind the scenes, so access is metered by credits. During testing, a gap let usage run up to roughly $300 before the guard caught it — because the check was sitting in the experience instead of locked at the meter where the money actually moves. Caught in testing, contained, and turned into a hard rule for production: the financial guardrail lives at the meter, full stop. This is the textbook reason you run a test phase before you scale.

Every one of these traces back to the same single signature: unverified agentic output. And that's the point — catching that signature, naming it, and engineering it out is exactly the professional discipline this whole project is built on. You don't get that ability by just prompting an AI and trusting the output — it comes from hard-won experiences through old-fashioned software engineering. The tools did what tools do. The judgment is the human's job, and that's the job I take seriously.

Why I'm betting everything on this

Because it worked. Strip away the rough edges and the core was validated in the most undeniable way possible: it changed my mother's life. A blind woman picked up a phone, talked to a computer, and the computer was genuinely, daily useful to her. That's not a hypothesis anymore. That's proof. And once you've proven a thing can hand someone their independence, you don't walk away because the first test had rough edges. You take what you learned and you build it right.

So that's what I'm doing now — building the production version with the full rigor I bring to client work, with the AI as my co-developer, not my replacement. Two brains on one challenge: the AI brings speed and breadth; I bring the engineering judgment, the security paranoia, and the refusal to ship anything I don't understand. Every line gets verified. That's how this technology is meant to be used.

Here's why the stakes are worth everything:

Around the world, an estimated 43 million people are blind, and another 295 million live with moderate-to-severe vision loss. (WHO, IAPB Vision Atlas) Those numbers are climbing — by 2050, blindness is projected to reach 61 million and moderate-to-severe impairment 834 million (IAPB) — and the burden falls hardest on lower-income regions, where it runs several times higher than in wealthy ones.

Now hold that against this: the world just got handed an AI superpower. Sighted people are using agentic AI to write, research, plan, and work at a level that genuinely feels like magic. Most of these tools were built screen-first — which quietly leaves hundreds of millions of blind and low-vision people on the wrong side of the door again. That's the whole mission: not "an app for blind people," but equal access to the agentic AI revolution for everyone the screen-first world keeps forgetting.

And the same agentic technology makes that reach genuinely possible:

The bottom line

The first phase of The Blind Computer was a working idea, tested honestly and openly, that proved it can change a blind person's life — because it changed my mother's. It also did what a good test is supposed to do: it showed me exactly what has to be hardened before this is trusted at scale. Now I'm building that production version with a professional's discipline and an engineer's caution, and with your privacy and data safety as the first requirement, not the last.

I'm betting everything on this because the proof is already in. It changed one life. Now I'm going to build it well enough to change a great many more.

— Acea

Sources: WHO — Blindness and vision impairment · IAPB Vision Atlas