CodeLife: How I Use AI

It’s Me. Hi. I’m the Problem It’s Me.

I’ve struggled with the class of skills generally called “executive function” all my life. I could blame anything from being neurospicy to brain damaged to lazy, but they’re probably all in the mix. At an early age, I had to adopt systems to function the way normal people seemed to innately.

Over the years I’ve worked inside all sorts of systems: I learned how to people from Dale Carnegie. I got shipped off to Peter Drucker “Management by Objectives” training. I’ve ” Gotten Things Done”. I’ve bullet journaled. I’ve done Toyota Kaizen training and used Agile workflows and Kanban boards.

I’m not against any of them. I love a good process. I’m just garbage at maintaining focus long enough to make any of them work for me individually, because I, like most humans, am an exploding bag of idea marbles barely contained by a thin dermal layer.

AI: Before and After Claude Code

Until recently, I considered myself a reasonably savvy AI person. I kept up on the science, read the academic papers each month, and talked to people much smarter than I am as often as I can. I used ChatGPT and NotebookLM and Claude and Perplexity in browser windows and had lots of interesting conversations every day.

But none of that helped me actually organize my digital life, it simply replaced a smart colleague with access to google and spare time. But then a coder friend showed me how he’s running his Dungeons and Dragons game with the same simple tool set he used at work:

GIT: the code-versioning system the entire software world runs on

Claude Code: the “coding tool” from Anthropic

So how was he using the tools of his “day job” to maintain an elaborate fictional world?

Text files. Lots and lots of text files.

For all the fancy deepfake Sora videos that get all the headlines, it turns out almost everything actually interesting in AI is happening in text files. When someone says they “vibecoded an app” what they really mean is “I had AI write me 1000s of lines of text, which, when read by an AI, a compiler, or an interpreter, do something.”

Any software project is, at some point, network of text files: code, documentation, configurations, instructions. The reason Claude Code is good at coding is because it’s been designed to work with big, complex text files based on sets of rules (like, say, how the python language works.) The reason GIT exists is so that when you make 200 changes to 30 different text files all at once, you have a way of keeping track of, storing, reverting, branching and exploring those text files.

The magic is that Claude Code doesn’t give a hoot about what those text files are: it just wants rules.

Claude Code is Stupid Simple

Claude I think most people understand: it’s a large language model. A beast of a math engine that provides plausible “next word” completions based on a giant corpus of “stuff other folks have written.” Claude (and other LLMs) has trained on lots and lots of code.

But Claude Code is something different. Claude code uses the LLM in a loop exposed to the user:

while(tool_call):
    execute_tool()
    feed_results_to_model()
    repeat()

Modern code is delightfully easy to read, but in english, all this says is “As long as there’s a request to use a tool, use the tool and then report back to Claude. Then wait for another tool call.” It’s the same loop humans use: gather information, try something, see what happens, adjust. It’s not dissimilar than the military “OODA” loop: Observe, Orient, Decide, Act.

The “Act” here are the tools. Anthropic gives Claude Code a handful of very very simple building block tools: Read a file. Look up stuff in a file. Edit a file. Run a program. Conduct a websearch. Importantly, it can spin off new LLM agents that can have their own loops and tasks. Finally, it maintains a master todo list to keep track of complex tasks.

If all that sounds interesting, it should – it’s what a great executive assistant or team of research analysts do. The challenge then is simply to present Claude Code with sets of rules, constraints and tasks that allow it to function the way I want it to.

Talk to me Goose

A perennial discrete problem I’ve wanted to solve is “talking to my data.” We’ve got great ETF data here (sourced from FactSet primarily.) And most of the time, I just want to ask questions about that data, get answers, and ask more questions.

So I fired up Claude Code and started asking it about a CSV file full of ETF data I had. And through a dozen hours of conversations and trial and error, I was able to develop a small program that grabs all the useful ETF data I have available (directly through APIs), make a static, one-day snapshot of the whole ETF universe, and then create a set of rules – a “skill” in Claude speak – that tells Claude (or any LLM) what the data actually is and what to do with it.

You can try it yourself (In claude or gemini's chat windows, drop this in and type "go" or whatever you like. You'll get a turtle-speed version of what it's like locally)… here’s a zip file with two things in it: a data file (randomly thinned due to licensing), and a text file that has some formatting cues, a wall of text describing what the data in the file is, and how to make it useful, along with templates for tables and outputs.

This means I can finally just ask, in claude code:

“Make a REACT table of the successful ETF launches of December 2025” and it returns a this, ready to post:

It’s using my data, my QA controls and my templates to produce content exactly how I would do it if I spent 2 hours in a spreadsheet getting all the sorts/exclusions/errors cleaned up. This isn’t an LLM writing for me - i have my own weird luddite line in the sand on that fromt.  I'm just using an LLM acting as an actual assistant.

Building your Jarvis

Here’s why this was magic. I didn’t write any of this system -- not the code, not the stored text, or any of the other documents that make it all work.

I didn’t write the rubrics for data cleaning. I didn’t write test queries to make sure it all works, then run all those tests. Through back and forth discussion, sample files, error logs and iteration, Claude helped me take my messy brain and put it into rules.

It’s not enough to “know” that a reported expense ratio of 1000% is wrong, I needed to find out why, and then make sure Claude had a set of rules to get it right going forward. It’s not enough to know what I want a table to look like, I had to go through and iteratively describe it and tweak it until Claude had rules.

Like art, the trick with AI seems to be in its constraints. Making rules out of my messy life. Once I realized that might be possible, I went nuts.

“Claude, scan my hard drive for PDFs, categorize them based on content, resort them into appropriate folders, and build a dedicated search system for it.”

“Claude, let’s create a project framework for managing new ideas, starting with two old notion databases.”

“Claude, lets come up with a daily workflow system to keep track of everything im working on.”

“Claude, use what we’ve learned from this session to improve instructions for the next.”

Today, I have a collection of text files in a folder system. All the text files are synchronized through GIT, and anything large is sitting in a companion folder in Dropbox.

Fragility and Cruft Don’t Matter Anymore

My “system” is a collection of disparate markdown files and hand (claude)-made single-purpose tools in a constant battle of feature-creep. I can’t share my repository with anyone, because I’m not making software for other people, im just running my own life. In other words, I am making a bloated, single use, inefficient system.

And it totally doesn’t matter. If you run Claude Code locally from the command line, you can (if you’re brave) let it run rampant across your local environment at lightspeed. The thousands of files being tracked by this system? I’ve played around with a dozen different versions in a week. Want everything resorted in french? Boom. Want to recategorize a few thousand PDFs based on full-text analysis? Get a cup of coffee.

The actual real world impacts of throwing everything away and starting over are negligible to an AI that can read a novel in seconds. My entire career of writing – every single word I have saved – can be loaded into the working context window of a big enough LLM like Gemini. Compared to the storage and processing needs of something like, video production? Maintaining a giant sloppy pile of text files is stupidly fast, and with Claude constantly indexing and adding metadata, it gets less sloppy with each iteration.

In other words: I’m no longer the problem. I’m just the source of new content.

Practical Advice & the Nerd factor

I am not expecting everyone to adopt this pattern, but I do feel like I’m in one of those “seeing the future” moments.

• The Command Line rules. I’ve spent most of the last 20 years living inside increasingly annoying graphical user interfaces after spending the 20 before that watching text on a black screen. But I grow weary of the constant popups and ads and menu items and visuals designed to grab my attention. Moving the bulk of my time back to single windows of just text is … nice. Calm. Quiet. A lot of professional nerds know this, but I’d say the majority of folks I know in finance (who aren't themselves coders or bloomberg jockies) aren’t used to working exclusively in a monospace glow. That will be, for many, an impenetrable barrier. I'm finding it liberating.
• You can't really “just buy something.” I think the era of off-the shelf tooling will fade as the “master loop + tools” way of thinking about work escapes containment. The pace of development in AI is insane, and even within Claude Code, seems to improve every single day. By the time an “executive assistant” product makes it to retail, it will be light years behind it’s own potential.
• Owning your own data is more important than ever. This is true for both the obvious reasons (I have a personal source-of-truth library on academic finance) and exciting and inobvious ones (If I have my data locally, I’m no longer reliant on any commercial relationship or even working internet). The "personal archive" folks have been on this jam for years.  
• Start somewhere, but leave quickly. I started with a simple framework from a random guy I found on the internet (https://github.com/huytieu/COG-second-brain) but within an hour or two had thrown away 75% of it and rebuilt it, just by talking to claude about what it did and how. Do a search on “Personal Assistant” or “Knowledge Management” + Claude Code and you’ll find dozens of similar projects.
• Assume everything’s massively insecure. Once you let Claude – or any LLM – this deeply into your day to day life, concerns about both privacy and security are real. I’m deliberately not connecting any of my local system to my email or my calendar or my contacts right now: I have zero confidence I would know enough to keep those things “out of the cloud” in a secure way, and while it would be nice to “talk to” my email and calendar the way i’m talking to data and files, it’s also not that big a time suck to “alt-tab” over to gmail once in a while.

What This Actually Looks Like

So what does this look like in practice? Let me walk you through a typical morning.

I open a terminal window (CMD on windows, Terminal on Mac) and type Claude. Claude wakes up and immediately reads a file called workbench.md – essentially my desk blotter. It tells Claude where we left off yesterday, what’s in progress, and what matters today. Because it's written in a text file Claude's keeping track of.

“Let’s check the news” I say. Claude knows I have a skill called /briefing (another text file) that expresses my interests (ETFs, market structure, regulatory changes) and my reading history, because we had a conversation about it, and it stored it in a text file. It scans my RSS feeds, checks a few key sites, and returns a personalized brief. Again, just text. Like the old internet.

An idea hits me. “Let’s start a braindump on thematic ETFs fragmenting.” Claude creates a new document, I ramble for five minutes. Mostly it's stream of consciousness.  When I’m done, Claude has structured it into sections with headers, pulled out the key insights, and even flagged which parts need data to support them. Time to do some actual research.

“Show me all the single-stock ETF launches this year.” Claude Code switches to my /ETFData skill, queries the latest snapshot, excludes the garbage data (that 1000% expense ratio that’s actually a data error), and returns a summary. It knows my preferences because we’ve built those rules together over dozens of sessions.

An hour later, having been distracted by phone calls, I’m now working on an article and can’t remember where I read something about market maker incentives. “Search my library for market maker pricing and order types.” Claude searches through hundreds of PDFs I’ve accumulated – academic papers, regulatory filings, industry reports. Not just filenames, but full text content it archives everytime I ask it to add a new PDF. It returns a few papers with context, and a link to the file on my local hard drive.  

And so on...

At the end of day, I type “/wrap” (another skill I wrote with claude, that's just a text file). Claude reviews everything we touched, updates my workbench with session notes, commits changes to git with useful notes, and leaves breadcrumbs for the next session.

This isn’t a product demo or me being clever. . This is just how I work now. I make claude keep track, and if I don’t like something about the whole thing tomorrow?  I’ll just ask Claude to change it.

The Point

With a nod to Taylor, I know I’ve always been the problem. Every “productivity system” I’d tried demanded that I change to fit it. GTD needed me to capture every commitment. Bullet journals needed daily migration and legible handwriting. PARA needed perfect categorization and I can't remember my name on alternate Tuesdays.

Thinking of Claude Code as the capable assistant who lives in my file system flips my whole workstyle. I don’t comply with the system anymore – it complies with me. I ramble, it structures. I ask vague questions, it finds specific answers. I abandon a project for three weeks, it remembers exactly where we left off.

The name “Claude Code” makes it sound like a tool for programmers. It’s not. It’s a tool for thinking and working with ideas.

What I built wasn’t an app or a product. I built an execution layer for my own cognition. The “code” isn’t Python or JavaScript – it’s the grammar of how I think, captured in text files that any future AI will be able to read.  Knowing just a TINY bit of code -- being comfortable with it -- is helpful, but not required.  

Don't believe me?  Open up Claude Code, paste this whole article in and say "help me do this".

You might be surprised.

P.S. - there’s so much interesting thinking going on about this precise topic it’s impossible to keep up. This is hardly a new idea. Here are a few jumping off points – just from the last few weeks:

How Claude Code Works: https://www.youtube.com/watch?v=RFKCzGlAU6Q
Why “Skills” Are Cool: https://www.youtube.com/watch?v=2Vcn2bAu2FA
Here’s One Guys personal Version: https://www.youtube.com/watch?v=D0nDWQdN3F4 
And another's: https://www.youtube.com/watch?v=aYAVSG4Ra40 
And another's: https://www.youtube.com/watch?v=Jsh_XbUynx0