@adlrocha - Agents will make Code and Apps obsolete

How Mr.Malone showed me I could build a financial assistant using only English, Markdown, and Claude Code

Karpathy already predicted it in 2024, “English is the hottest programming language”. I have to admit that while I agreed with the claim then, I wouldn’t have expected that we would have come such a long way in a bit less that two years.

To me, and many others, the release of Opus 4.5 into Claude code was that moment where English really became the best way to interact with computers. You described what you wanted and Claude code would get you working code that did what you wanted.

But after some experiments I’ve been doing the past few days, I not only think that English is the hottest programming language, I also think that agents have made programming languages and applications obsolete. Let me try to explain to you why.

I am glad to be a mess

I’ve always been a mess managing my personal finances and investments. I’ve tried everything, and I’ve always failed at it.

• Open-source and SaaS personal finance apps like homebank that I could use out-of-the-box.

• Writing my own web app with a simple web interface that allowed me to track expenses and make updates over my portfolio. This is actually the one that led to better results for me, but the fact that I had to squeeze maintenance work for the app, even if minimal, along with my daily responsibilities resulted in me not doing it, and ending up abandoning the app (and thus the habit)

• An excel sheet with monthly expense tracking and portfolio performance. This is what I am using now, but updating the sheet every month is taking me close to what took me to add the few changes and features needed for my app.. So I was back to square one.

But we live in the world of Baselight, LLMs, coding agents, and agentic social networks. There had to be a better way.

And not only had I found it, in the process I came to a realisation: Agents may be all we need!

Where it all started

It all started when I was reading a post from Lyn Alden’s newsletter where she was describing how the overnight financing markets were running into liquidity shortages, and that the Fed would likely begin balance sheet expansion in the not-too-distant future.

I then thought, “wow, it’d be cool if I could track these signals myself in some way, and this data must be public through the FED data”.

So I went into Baselight and asked the question that you see in the image below. Bingo! We had what I needed.

I then asked Baselight to make an analysis about recent events where the FED had to step in to inject emergency liquidity into the repo markets. It came up with this cool table and descriptive.

I was doing this analysis between diaper change and diaper change, while having in the back of my mind the urge to find a better way to handle my personal finances. Lyn Alden, Ray Dalio, and all these renowned macro investors back their investment decisions and portfolio allocation in a lot of macroeconomic data.

When it occurred to me. What if I use claude code to create a financial assistant that helps me make better investment decisions leveraging all the data that we have in Baselight?

That is how it all started, by connecting the Baselight MCP to Claude code. Since then, things started escalating quickly.

The Birth of Mr. Malone

After the first prompt I quickly realised that I could not only use Claude code connected to Baselight to help me make better financial decisions, I could also provide it with all my financials so that it could help me keep track of them, evaluate together my financial health, and make investment decisions using my own personal context instead of making them in the void.

I could even use it to track all my historical decisions so in order to help avoid recurrent mistakes (at some point I had a specific notebook for this, I don’t know where it is anymore. That’s how that went).

That’s how Mr. Malone was born

Note: Indeed, the name of the assistant, Mr. Malone, comes from Kevin Malone, one of the members of the accountant departments at Scranton’s Dunder Mufflin from The Office (the TV Show).

And here comes the realisation, why write the code for an assistant, if I could instruct claude code to become the assistant that I need.

Fine, Claude code is a coding agent but turns out it is general-purpose and customisable enough for you to instruct it to become any kind of specialised agent, provided the right context. No need for a single line of code. Only a descriptive enough CLAUDE.md to steer the “logic” of the agent.

Even more, all the persistent data storing the information about my expenses, assets, etc. (i.e. the memory of the agent) can live in a set of markdown files. No need for a cumbersome and expensive database infrastructure (or a deep technical background to run it). Many agents already use markdowns or JSONL to store their long-term memory and context. Why not use the same approach for the “database” of my agent?

Implementing agents using English language, a set of markdown files, and in my case an MCP connection to Baselight, has also several interesting consequences.

• I can use git for version control and Github as the hosting service to sync it among all of my devices.

• I am currently using Claude code as the “reasoning machine” for my agent, but I could use it with any other agent that supported CLAUDE.md (or AGENTS.md), MCP connections, and the tool calls that I needed (that at this point is basically calling Baselight, reading from files, writing to files, and in some exceptional cases web search. Nothing that most agents do not already support).

• The assistant can run anywhere where Claude code (or other agents) run: your local device, a sandbox environment in the cloud… anywhere. And the dependencies are minimal: Claude Code. You pull the repo, you start the agent in that repo, and you are good to go.

I pasted above the tree of my agent. As you can see, the implementation is just a bunch markdown files with CLAUDE.md being the entrypoint of the agent’s behavior.

Files like portfolio.yaml, action_plans.md and decisions.yaml make up the memory of the agent, and other files like themes.md are used as a way to extend the core behavior of the agent to align with my most recent investment theses.

The operation of these extra files like themes.md is similar to that of Claude skills. For those curious about them, this is the structure that these files currently have.

Apart from these markdown files, the repo only includes a set of scripts used by git push and pull hooks to encrypt sensitive data before pushing it, and conveniently decrypting it when pulling the repo (all this lives in a private repo, but I am a bit paranoid about privacy. Even more after reading this tweet).

Finally, the queries directory include a set of pre-built SQL queries for the agent to pull the data from Baselight that it recurrently use in order to update “its view of the economy”.

Finally, docs include blog posts, articles and papers from different sources that I want my assistant to keep around and eventually review when making decisions.

Obviously, I not only did not write or execute a single line of code to implement my assistant, I also didn’t write any of these markdown files by hand. I may have edited a few sentences here and there, but the code was all generated by Claude code.

Even more, I was driving some of the features in the implementation with the first version of the agent already running, so Claude code was acting at the same time (and in the same session) as Mr. Malone and my coding agent. Mixing up the context of the same session for two very distinct purposes may not be the best idea, but I have to admit that the context size of modern models has become large enough not to experience any relevant regression in the agent’s output by doing this.

Mr. Malone In Action

Here’s an example run of Mr. Malone. It first performs a few Baselight queries to build its context, and then generates an output with the analysis. Of course, the analysis is way more extensive and includes a detailed analysis over my portfolio (but I’ll redact that for now, if you are interested about my allocation and want to discuss investments drop me a message).

I even have a few recipes baked into Mr.Malone to help me analyse specific economic themes and run recurrent queries in order to build the context with specific knowledge for a decision.

The result of my analysis or investment decisions may generate as an output an action plan that is stored in memory and taken into account for future decisions and agent interactions. I can easily review my action plans through the /action-plan recipe as you (see image below).

I could also go into the process of feeding portfolio and expense updates to Mr. Malone, but I don’t want to make this too long.

I am considering to, at some point, remove all private info, generalise the repo, and fully open-source Mr. Malone for everyone to benefit from it. Again, if this is in any way of your interest let me know.

Agents will make code and applications obsolete

This unplanned experiment with Mr.Malone made me realise something about the future of AI: it may not only make code but also applications obsolete.

I just needed an interface to an intelligent agent with enough customisation capabilities to get a computer run the logic that I needed. It all boiled down to:

• A reasoning machine.

• The right instructions to steer “the logic”

• The right context and data sources (this is why Baselight is great :) )

• The required (and ideally minimal) connections needed for its operation.

Many of you may counter-argue, “sure, you haven’t written (or executed) a single line of code, but you still need a terminal and the application is essentially a cli”.

But this is just a consequence of the environment (let’s call it runtime) where the reasoning machine that I am using is running. Soon, we will get the equivalent of claude code with a graphical user interface where one of its “tool calls” or “connections to the environment” is to depict graphical artifacts.

What the hell, Claude and ChatGPT already do that on their apps, and we make beautiful charts on Baselight, so it would be quite straightforward to add that to Claude Code or Mr. Malone. Actually, I may even be able to run Mr. Malone directly in ChatGPT and Claude out-of-the-box (I’ll try this and report back).

And then, why would one need to implement an application in the first place if it could have an agent do what they needed? Sure, LLMs are a bit unreliable, they hallucinate, and they are stochastic machines and there are things for which we need deterministic outputs. But LLMs are becoming smart enough that with the right tricks you can steer their behavior to be close to that of the deterministic logic of an application.

As I was working on Mr. Malone and writing this post, I couldn’t get out of my head this LLM OS image used by to describe his idea of Software 3.0.

LLM OSes are not only a reality now (we tend to call them agents now), but we are reaching a point where everything may be running as an LLM OS.

English really is the hottest programming language. And Mr. Malone is just the beginning.