My most useful software is a folder of text files

I’ve been thinking a lot about what “software” actually is.

Strip the jargon away and a piece of software is just a set of repeatable processes with inputs and outputs. You give it something, it runs through some steps based on rules, and it gives you something back.

That’s the whole thing.

Until recently building software has meant writing code, which locked out most people (me included).

If you didn’t know Python or JavaScript, you were stuck either paying someone to build what you wanted or making do with whatever someone else had already made.

No-code cracked the door open

Then tools like Zapier and n8n came along and let non-technical people wire their own workflows together.

This was a big step forward. It meant that people could build their own systems by gluing together other software tools. You were essentially making your own custom software by combining other people’s software.

But doing it this way has its downsides. You have to think about data formats. You have to deal with some syntax. And the workflows themselves are rigid. If a weird input comes in that you hadn’t planned for, the whole thing breaks.

You’re also usually paying for multiple different SaaS platforms, often just to get fairly basic functionality.

The bit that’s different with AI

AI can handle uncertainty. It can read an unclear instruction and figure out what you probably meant. It can receive an input it’s never seen before and make a reasonable call about what to do next.

That means you can build a system where an AI is the thing actually running it, making judgment calls as it goes, rather than a rigid algorithm following pre-planned branches.

And because the AI understands plain English, your “code” becomes instructions written in a markdown file (markdown is just plain text with a bit of formatting the AI likes, a plain .txt file would work too).

My personal OS is just a folder

I’ve written before about my personal operating system. If you missed it, the whole thing is a folder on my computer with a master instructions file in markdown. When I fire up Claude Cowork it reads the master file, which links to other files, each with its own process instructions.

It’s structurally identical to a piece of software. Main file. Sub-modules. Conditional routing based on what I’ve asked for. Only instead of being written in code, it’s written in English.

The data side is the same story, at least at the personal scale I’m using this at. Where a traditional app would have a database with schemas and tables, my system just has folders full of markdown files. If I ask about my goals, the AI opens the goals file and pulls out the bit I asked about. No SQL, no schemas, no migrations, just sensibly named files. At bigger scales a real database still makes sense, but for one person running their life it’s overkill.

I didn’t even write most of it. I told the AI how I wanted my system to work and it created the folder structure, the master instructions, and all the sub-files for me.

Skills are basically functions

One thing worth mentioning is that Claude Cowork and a lot of the other AI systems have started introducing concepts like skills and plugins. The easiest way to think about them is as the AI equivalent of functions in code.

A skill is a predefined set of instructions that the AI follows every time it runs the same process. When I type /today in my personal OS, that’s a skill firing. It’s supposed to follow the same steps in the same order each time.

The whole point is to claw back some of the determinism you lose by running a system with AI. You keep the flexibility for ad-hoc stuff, and you lean on skills for the repeated processes you want behaving consistently each run.

The trade-offs are real

Should all software be replaced by this kind of system? No.

Software is deterministic. You run it twice and you get the same result. AI isn’t. I can type the same thing into my system two days in a row and get slightly different outputs, which is fine when I’m brainstorming and annoying when I expected a specific format.

Software is also cheap. Code runs for almost nothing and can handle thousands of tasks at once. An AI-powered system calls a model for every decision, which uses tokens and takes time. For a personal OS juggling ad-hoc tasks across a few projects, that’s absolutely fine. For something that needs to run thousands of times a day with predictable output, it’s probably the wrong shape.

AI can run your system and build you a system

The exciting thing is that the same AI that runs your plain-English system can also write you real code whenever you need it.

If you hit a point where part of your system needs to be predictable, repetitive, and cheap, you can ask the AI to write you actual code for that bit. Claude will happily build you a script, an automation, or a proper app. Your plain-English system can then call into it when it needs to.

Example: I have a folder to manage my personal finances. I drop my PDF bank statements in there each month. Claude can read the PDFs so it’s tempting to just ask it to summarise them each month.

But I discovered this is pretty inefficient and can be prone to mistakes because the AI struggles to read the rows and columns correctly.

So instead I got Claude to write a script (some code) which will read the statements in a deterministic, rigid way, and then output the data into a CSV, which the AI finds much easier to read.

So you’re never really stuck. You start with a folder of text files and graduate individual pieces into real software as and when the economics or reliability matter.

Why I think this is a brilliant on-ramp

Most people who want to get into building software get lost in syntax before they get anywhere near the interesting bit.

Building a plain-English system with Claude Cowork (or Notion Agents) skips the syntax entirely and drops you straight into the interesting bit, which is systems thinking.

You start asking the right questions.

• What are the repeatable things I do and how can I systemise them?
• What are the inputs?
• What decisions need to be made along the way?
• What’s the output?
• What should happen when something unexpected comes in?

Those are the same questions an engineer asks when they architect a real application. You just happen to be writing your answers in English instead of code.

If you’re curious about how software actually works, I genuinely think building your own AI-run personal system is one of the best ways in right now. You’ll build your systems-thinking muscles faster than a tutorial would, because you’re wrestling with a real system you care about.

And the nice surprise is that you’ll end up with something useful for your actual life along the way.

That’s it. Start with a folder of text files and go from there.