Building EEditor: How AI Brought an Old Programmer Back to Shipping

The notebook problem

I've been a programmer for a long time. Long enough to remember when the tools were simple and you could hold an entire system in your head. Long enough to have accumulated decades of half-written ideas in notebooks, text files, and forgotten repos.

Some of those ideas were small — a better way to manage daily notes, a personal database that didn't require spinning up a server, a task manager that thought more like Lotus Agenda than a kanban board. Others were bigger — a text editor that could embed a real programming language, one where you could write executable code inside your own documents.

For years, these stayed on paper. Life got in the way. The ecosystem moved faster than I could keep up. The gap between having a clear vision and being able to implement it kept growing. Frameworks changed, toolchains got heavier, and the energy required to bootstrap a project from scratch felt increasingly disproportionate to the idea itself.

What changed

Then something shifted. AI coding tools — specifically Claude Code and the broader wave of LLM-powered development — arrived, and they changed the equation in a fundamental way.

It wasn't that AI wrote the code for me. That's not really how it works, and anyone who's tried knows that. What it did was collapse the friction between thinking and building. The distance between "I know what I want" and "I have working code" went from weeks to hours in many cases.

Here's what I mean concretely:

• Prototyping became conversational. Instead of spending a day setting up a SwiftUI project structure, I could describe what I wanted and iterate on it. Not perfectly — but fast enough to test whether an idea had legs.
• Knowledge gaps became manageable. I hadn't written serious Swift in a while. The language had evolved. SwiftUI was new to me. Instead of spending weeks relearning, I could ask questions in context, get working examples, and learn by doing.
• The boring parts got faster. Boilerplate, serialization code, repetitive UI patterns — these used to eat days. Now they take minutes. That freed up time for the parts that actually matter: the design decisions, the UX, the architecture.
• Debugging became a dialogue. When something broke, I could show the error and the context and get meaningful suggestions. Not always right, but always a useful starting point.

What EEditor actually is

EEditor is a native text editor and personal information manager for Apple platforms. It runs on macOS, iOS, and iPadOS. It's built entirely in Swift and SwiftUI.

But what makes it different from other editors is what's inside: a full Lisp interpreter called EELisp, backed by SQLite, that lets you define tables, run queries, create interactive forms, and execute code blocks — all from within your own Markdown documents.

The idea came from two old pieces of software that influenced me deeply:

• Lotus Agenda — a personal information manager from 1988 that understood categories, auto-classification, and dynamic views long before anyone used the word "productivity app." It thought about information the way my brain does: loosely structured, categorized on the fly, always in flux.
• dBASE III — the database that taught a generation of developers that data management could be approachable. You typed commands and things happened. No ceremony. No configuration files.

I wanted to combine these ideas in a modern context: an editor where your notes, your tasks, your data, and your code all live in the same place, and where a real programming language ties them together.

The role of AI in building it

I want to be honest about this, because I think the discourse around AI and coding often veers into extremes — either "AI will replace programmers" or "AI is just autocomplete." Neither is true.

What AI did for EEditor was serve as an accelerator for someone who already knew what they wanted to build. I had the architecture in my head. I had decades of opinions about what a text editor should be. What I didn't have was the stamina to fight through every SwiftUI quirk, every SQLite binding issue, every platform-specific gotcha from scratch.

Claude Code, specifically, became something like a very knowledgeable colleague who never gets tired of answering questions. Someone you can pair with at 2am when you're deep in a problem and need a second perspective. Not a replacement for thinking, but a tool that makes thinking more productive.

Some concrete examples:

• The syntax highlighting engine for 24+ languages was something I could describe at a high level and then refine through iteration. Weeks of work compressed into days.
• The Lisp interpreter itself — 80+ built-in functions, macros, closures, pattern matching — was designed by me but implemented much faster than it would have been otherwise.
• The task management system with auto-categorization rules, natural language date parsing, and recurring items: I knew exactly what I wanted from years of using Lotus Agenda, and AI helped me get there without drowning in implementation details.

Why this matters for "old" programmers

I use "old" loosely. What I mean is: people who've been building software for a long time, who have accumulated deep knowledge about systems and design and user needs, but who may have drifted away from active day-to-day coding.

Maybe you moved into management. Maybe you started a company. Maybe you just got burned out on the ever-accelerating churn of tools and frameworks. Whatever the reason, you have notebooks full of ideas and no clear path to turning them into reality.

This is where AI tools genuinely shine. Not for beginners who don't know what they want — though they can help there too. But for experienced builders who have a clear vision and just need the implementation friction reduced.

The gap between "I know exactly what this should do" and "I have a working prototype" has never been smaller. And for people who've been away from the keyboard, that's not a small thing. It's the difference between another idea staying in a notebook and a real product shipping on the App Store.

What I believe now

EEditor is on the App Store. It's open source. People use it. That's not a humble brag — it's genuine disbelief from someone who had this idea for years and only now managed to build it.

I believe we're in an era where the balance of power has shifted. You no longer need a team of ten to build a serious application. You need a clear vision, domain knowledge, and the willingness to iterate. The tools will meet you halfway.

This doesn't mean AI is magic. It still hallucinates. It still writes code that doesn't compile. It still misunderstands requirements in subtle ways. But the floor has been raised. The minimum viable effort to go from idea to working software is dramatically lower than it was even two years ago.

If you're someone who's been sitting on ideas, waiting for the right moment or the right team or the right framework — this might be the moment. The tools are ready. The question is whether you are.

---