Last year was challenging to say the least. For a significant stretch last year, I felt left behind by how quickly the AI space was moving. I dabbled less and it led to even more paralysis and lack of motivation to invest time. I did not recognise the loop I was in and what it took was a set of small steps.
This is what I wish someone would have told me:
What do we get wrong in the beginning?
People start using AI like a search engine. They run ad hoc financial models through browser prompts. This leads to to a lot of mess, disconnected context, and unverified input files. The challenge is that there is no permanent place for a web chat to hold contextual information. It does not have access to your files and does not know your folder structure or your historical analysis. It cannot cross-share or reference data. Every session starts from limited context, so you spend a ton of time re-explaining your business context to it.
What changed the game for me?
An integrated development environment (IDE). I have used Claude Code and Cursor. However, I am sure Codex is equally relevant. There are many options and it genuinely does not matter which one you pick as your core operating system. These are one-stop shops that can read your local files, connect to your data warehouse and read your schema. They execute commands on your laptop and in your terminal. They can run multiple agents doing a job once or recurringly.
What they still need is a clear set of instructions and active review and audit of everything they deliver. That is the part of the job that has not gone away. Refer to my deep dive on this topic. This first step needs limited permissions. You just need to procure one of these IDEs and then play around with it.
What turns it into a system?
Everything so far makes you faster on your own. It does nothing for anyone else, because an agent has no memory. There are two ways of fixing that:
Connecting to your own data needs a set of MCPs. One to your financial database and maybe one to your data warehouse. That is super critical, and it is not something you do alone: it means data engineering, a security review, and procurement. For example, Snowflake MCP.
The repository structure to organize everything. The structure is the part people underrate. A repository is where the context lives instead. It is like a shared intelligence engine for your company. You create one structure, and everyone copies it: shared folders, team folders, and space for everyday work.
Then we need to operate a consistent rhythm. You start the day by pulling the latest context out of it or “The Pull”. You finish by pushing the work you have done back in, so it is backed up and can be audited “The Push”. Every time you pull, you get new skills and context somebody else built. Every time you push, you are doing that for them.
How do you stop the cost running away?
This is critical and does not always get sufficient attention.
A lot of day-to-day tasks are straightforward such as “Summarising a document”. “Answering a question with basic search”. You do not need an advanced model for these tasks. Keep a lower capability model as the default and use the expensive ones only as an escalation path. When to escalate requires judgment and there is no fixed rule. It is a function of how complex the problem is and how nuanced the topic is. Summarising documentation sits at one end. Asking why revenue performance is behind sits at the other.
This matters because of the token-maxing era we have just been through. You obviously still need budgets per person. However, having a budget means people can max the budget. You still have to make sure teams know how to manage this through training and guidance.
How would this look in practice?
You pull the latest context from the repository. >>>>
You identify a problem worth solving. >>>>
You work with an agent on it and it produces the analysis. >>>>
You verify the calculation and audit the numbers, because you retain accountability for any number you put your name to >>>>
Once verified, you commit it to the repository and push it. That is where the compounding comes from, and it only works if people actually do the last step.
Where would I start reading?
If you have never used a repository, start with the resource a beginner’s guide to GitHub. The Claude Code best-practice documentation is great for IDE best practices and is also relevant for other tools such as Codex. For the common pattern across tools, GitHub’s Copilot customisation cheat sheet is very helpful. However, how to apply these skills is covered in OpenAI’s guide on identifying and scaling use cases . It is great for new ideas.
Lastly, two other useful resources: While The Pragmatic Engineer and Lenny’s Newsletter are product and engineering publications, they have up-levelled my thinking more than anything written for Finance per se. That is not a coincidence. The tooling for most of these was built for those functions first and it is why their material is still very helpful if you want to be ahead of the curve.
So what should you do next
Start with the IDE. Everything else follows from there.
