Folders All the Way Down

It’s been a month since I launched my book, The Stoic Systems Thinker.

I’m still adjusting to life after launch. For 18 months, the book was my main focus. I had no time for other projects. But now, it’s just out there, finding its readers.

I’ll be honest. I still don’t entirely know what to do with myself. Yes, I’m still thinking about the project — devoting time to selling the book and sharing its ideas. I spent last weekend stretching outside my comfort zone by canvassing Ann Arbor bookstores to schedule author events for this fall (more to come!). But the work doesn’t come close to filling the hours the writing did.

I’m still writing. But I’m also exploring other projects. Specifically, I’m building practical AI systems for both professional and personal use.

My most ambitious project is a personal knowledge management system that helps me plan (and execute) my day-to-day work. I rebuilt an earlier Notion-based “Second Brain” system (I wrote about it in 2024 and 2025) into an Andrej Karpathy-inspired setup that organizes much of what I do and doubles as my thinking partner. In April, I wrote about some of the principles I follow.

Note: The full build is beyond the scope of this essay, but if you’re interested in learning more about it, I’ve put the project on GitHub.

Outside of that work, I’ve built several other systems to scale my time across different areas of my life, including a data science system for my analytics work, a “chief-of-staff” layer to help me with meetings, team management, and career development, and a marketing engine for selling my book.

I’ve watched countless YouTube videos and experimented with different tactics. And while I know I still have much to learn, there’s one thing I keep coming back to. Everything I’ve built that works shares one feature — an idea that’s been around for decades.

It’s just folders.

I’ve always been a bit of a tech geek — from the Commodore my dad brought home in the early ’90s (where I developed a comfort level with the command line) to our family Mac on the desk in our TV room during my teenage years.

During my senior year of high school, I wanted my own computer. I bused tables and delivered pizzas and saved enough money to buy a top-of-the-line custom-built Dell. I think I spent $2,000 on that thing — a ridiculous sum in 1999 dollars. But I wanted a powerful machine, and nothing would change my mind (I have yet to grow out of this tendency).

In August of 1999, I left my New Jersey house with my new Dell, saying goodbye to my dial-up modem and moving into a dorm room at the University of Maryland with an Ethernet jack in the wall. If you’re old enough to remember the shriek of a dial-up connection, you can understand how amazing that little jack was.

From the moment I plugged in, my technological life improved by orders of magnitude. What once took hours was now on my computer in seconds. I downloaded music, movies, and software — from Napster and beyond — almost as fast as I could click.¹

And I wasn’t the only one doing this. Almost everyone I knew on campus scoured the relatively young internet, downloading anything they found interesting. Our single greatest bottleneck — download time — was effectively eliminated.

But plugging into a campus network came with another gift — we could share folders with each other.

And share we did.

It was as simple as right-clicking on a folder and making it visible to the local network. Students shared music libraries, games, movie collections, and files for classes — it was a treasure trove passed freely among 30,000 of us.²

In 1999, we didn’t have a great way to search the network. Google’s technology was in its infancy and not yet set loose on university networks. Instead, we found things by navigating the network’s folder structure. The network housed the dorms on campus. The dorms housed their users (students who lived there). The users shared their libraries. We dug until we found the file we wanted, then opened it or (more frequently) copied it to our own hard drives.

Nobody gave us a lesson in how to navigate the network. Nobody needed to. We just did it. A folder inside a folder inside a folder is incredibly intuitive.

Fast-forward 27 years, and that same structure is the backbone of how I work with AI.

I know that probably sounds like a stretch. What could a 1999 dorm network possibly have to do with large language models? Hold that thought — the folders come back. First, we need to dig into the basics of modern AI models.

The Stoic Systems Thinker is my first book, published in June 2026. It combines the emotional resilience of Stoicism with the analytical precision of Systems Thinking to close the gap between how the world works and how we think.

“‘Timely and timeless’ captures this book perfectly.”
Bethan Winn, Author of The Human Edge: Critical Thinking in the Age of AI

Way back in 2022, I created a poker education product called Solver School. I had been writing for two years about solvers — software that calculates optimal poker strategy. I organized all that I had learned into a training course containing nine sequenced modules, over 100 video lessons, and solver files complete with ranges and templates.

Note: I’m currently releasing the entire library for free on YouTube. Bookmark the course playlist here.

In the second video of the first module, I have a slide that explains, in simple terms, how to think about solvers as a study tool.

I taught my students not to worry about how the algorithms arrived at a solution, but instead to focus on learning how varying the inputs affects the outputs. I used this simplified metaphor — a function machine — to make my point. The idea underlies much of the rest of the course.

That same metaphor applies to AI and large language models (LLMs). Strip away the hype, and an LLM is simply a function machine. It takes an input. It produces an output. That’s really it.

The inside of the machine — how the input becomes the output — is largely a black box, even to many of the people who build these models. But we don’t need to see inside the box to work with it well. We can observe it, vary the input, and watch what changes in the output. Anyone who has rewritten a prompt three times to get a better answer has already run this experiment.

The framing sounds almost too simple. Because it is. But it carries the single most practical idea I can offer about AI: if the output disappoints you, the input is the only lever you hold.

For a while, that lever was short. When ChatGPT first arrived, your input was whatever you typed into the chat box (plus whatever system instructions the provider slipped in behind the scenes). Every conversation started nearly from scratch, which meant every conversation leaned entirely on how well you happened to phrase that prompt. We called this skill “prompt engineering.”

Over time, the lever grew as models could accept lengthier inputs. And with that came features like custom instructions, memory across chats, and APIs that let you embed models in your workflows.

In the past year, many of these tools escaped the browser entirely. I now do most of my AI work in Claude Code, a tool that runs directly on my computer. Despite the name, coding is a small share of what I use it for. These are language models — their power is that you can hand them any workflow you can describe in natural language, such as analyzing, drafting, organizing, and editing. (OpenAI and Google make comparable tools; the general idea is the same.)

Most of these tools also let you create standing instruction files, stored in simple formats like Markdown or JSON. In Claude Code, this is the “CLAUDE.md” file, whose contents are loaded into every chat.

Yet for all these additions, an LLM still just accepts an input and generates an output. The model itself is stateless — it remembers nothing between submissions and starts fresh every time.

Not only have the ways we can inject inputs into the model grown, but so has the amount of input these models can accept — the context window, in industry terms. Early models could hold a few pages. Current models can hold a novel.

But “can accept more” and “performs better with more” are two very different things.

Researchers led by Nelson Liu published a study in 2023 with a memorable finding: when relevant information is buried in the middle of a long input, models measurably lose track of it. They called their paper “Lost in the Middle.”

The pattern has been confirmed repeatedly: as inputs grow longer and noisier, output quality degrades — even on tasks the model handles easily at shorter lengths.³

This shouldn’t surprise us. We run into the same issue ourselves.

Hand a person a briefing where two paragraphs matter and eighteen don’t, and watch what happens. They get confused. They anchor on the wrong details. Our brains naturally try to make use of everything we’re given — relevance is assumed from inclusion.

Neil Postman saw this coming in 1985, albeit with a different technology. In Amusing Ourselves to Death, he argued that the telegraph broke something he called the information-action ratio: by generating “an abundance of irrelevant information,” it buried the news we could act on under news we couldn’t. Irrelevant, fragmented information, he warned later in the same book, “creates the illusion of knowing something but which in fact leads one away from knowing.”

He was describing the media of 1985. He could have been describing a bloated prompt.

Language models behave similarly. Feed one a pile of unnecessary context, and it will dutifully try to use it, weaving in details you never wanted and drifting from the actual task. So the rule of thumb is the one you’d apply to briefing a colleague: include what drives the output; cut everything else.

If you’re typing one prompt at a time, this is manageable — you curate each input by hand and stay focused.

But the moment you try to automate your work — passing the model whole workflows instead of one-off questions — hand-curating every input becomes impossible. You need the right context to show up at the right moment without you standing there selecting it.

That’s where the folders come in.

Earlier this year, Jake Van Clief and David McDermott published a paper out of Eduba and the University of Edinburgh titled “Interpretable Context Methodology (ICM): Folder Structure as Agentic Architecture.” Their thesis is simple: you don’t need an elaborate software framework to orchestrate AI work. A well-organized folder hierarchy, filled with plain-text Markdown files, is the orchestration. ⁴

This is nothing new — and the authors say so themselves. Van Clief and McDermott frame it as “going backward before going forward,” arguing that the principles that made computing work in the 1970s apply directly to AI systems in the 2020s.

Remember that “CLAUDE.md” file I mentioned earlier? The paper recommends using this approach — with a context file (aptly named “CONTEXT.md”) embedded in every folder throughout the system. Each context file contains instructions and a map of everything in its folder.

The paper builds this into multiple hierarchical layers. The top-layer file is an orchestration map that loads in every chat window. When the model is given a task, it reads the map, navigates to the relevant folder, and loads the additional context that folder contains. More importantly, it only loads that context and nothing else.

If this sounds familiar, it’s because it operates much like the university network I described earlier, except with a superuser — the LLM — that knows where everything is, thanks to its mapping files. Network to dorm. Dorm to user. User to library. The model finds what it needs the same way I found music in 1999 — by navigating a structure where every level contains the next level down.

Those mapping files scattered throughout the folder structure — they’re just rules. A rule is a decision you made ahead of time and wrote down, so nobody has to decide in the moment. When I write “here’s how I structure this report” into a folder, I’m doing the work once and documenting it, rather than hoping the model guesses right on every future prompt.

Let’s look at a specific example from my data science system. A regular part of my work is a client readout. I take a set of marketing data, analyze it, translate the findings into recommendations an executive team can act on, and build PowerPoint slides that tell the story. That workflow is a bundle of distinct tasks that follow a consistent pattern.

I can write each of those tasks down. How I approach storytelling. How I structure a recommendation. What I want my slides to look like. All of that lives in one folder, permanently — you can think of it as the recipe. This week’s client data is the ingredients — it changes every engagement, and it gets dropped in fresh each time. The recipe teaches the model how to think about the task; the ingredients are what it thinks about today. Together, they form the full input — and the output is something I can use or build on.

This analysis readout is just one workflow. Reporting lives in a different folder. Visualization in another.

The difference this makes is not subtle. Because each task loads a focused folder instead of everything I’ve ever written down, the model runs faster. The outputs track my actual standards instead of a vague average. And — in my experience — it hallucinates noticeably less because it isn’t reaching into irrelevant context for material.

One caveat: Van Clief and McDermott limit their claims to sequential workflows in which a human reviews each step. They’re honest that heavy-duty software frameworks still win at things like error recovery and running many tasks at once. Folders won’t replace AI engineering.

But they don’t need to. For the way most of us actually work, the folder structure is more than enough.

Why does this keep happening? Principles behind a Unix file tree in the 1970s, a dorm network system in 1999, and an AI agent architecture in 2026. The same shape keeps winning across five decades and wildly different technologies.

It keeps winning because it encodes something true about systems.

Donella Meadows, the great systems thinker, made the case in Thinking in Systems: Complex systems that work invariably evolve from simple systems through stable intermediate forms — and the result is always hierarchical. Within a subsystem, the relationships are dense and strong. Between subsystems, they’re sparser. What belongs together lives together.

That is a folder. It’s also the Systems rule from the DSRP framework — every whole contains parts — and the hierarchy idea I explore in Chapter 4 of my book. The campus contains dorms, the dorms contain students, and the students’ hard drives contain the libraries. Zoom in or zoom out — the structure holds at every level. It’s folders all the way down.⁵

The Stoic lens fits here too. The dichotomy of control — some things are up to us, some things are not — applies to this new tool as it does to everything else.

What the model does inside that black box is not up to you. That’s okay. You don’t need that visibility. You control the input, which is no longer limited to what you type into your chat box. A well-designed hierarchy of rules, files, and context automates that input. And a well-designed input yields consistent, reliable outputs.

Strip away the advanced technology, and what powers the whole idea is simply folders.

You don’t need a training course to start — just run a few experiments:

These four steps are small on purpose. Do them enough times, and they’ll compound into a persistent system. As Van Clief is fond of saying on his YouTube channel (which I recommend), the structure is the foundational piece. The models may evolve, but the folders will keep working.

And if you’d like help building something like this, reach out by replying to this email.

The hierarchy idea at the heart of today’s essay is one small piece of a much bigger framework. The Stoic Systems Thinker — my attempt to merge ancient Stoic practice with modern systems thinking into a single operating system for life — is now available on Amazon. If today’s essay landed with you, the book goes much deeper.

You can get the book here: https://www.amazon.com/Stoic-Systems-Thinker-Michael-Lukich/dp/B0H3P4JKZ8

Thanks for reading. Back in your inbox in a couple of weeks.

All the best,
-Michael