Using Claude to built a Personal Finance Tracker

Introduction

One of the best habits for managing money is keeping track of your cash flow. A personal finance tracker makes this easier, but most of them share the same limitation.

Every expense has to be recorded manually. While entering a transaction only takes a few seconds, repeating the process every time you spend money quickly becomes tiring. As a result, many people gradually stop keeping track of their finances.

My previous personal finance tracker had the same limitation. It worked well as a basic expense tracker, but I wanted to build something that could do more.

This project is my second attempt.

Using Claude, I aim to build a personal finance tracker with additional functionality. Throughout this article, I will explain my development process and reflect on what I learned along the way.

Why I decided to try Claude

When I was choosing an AI tool for this project, Claude wasn’t my first choice. It seemed overhyped, and its core functionality looked similar to Gemini. On top of that, Claude consumes a large number of tokens, which made me reluctant to try it.

After discussing it with others, however, I received consistent feedback that Claude performs much better when writing code and developing applications. That reminded me of my experience using Gemini Antigravity to build my previous personal finance tracker.

Although Gemini Antigravity was capable of developing applications, I often struggled to get the results I wanted. Buttons didn’t function correctly, layouts were sometimes incorrect, and even simple problems often took several prompts to fix.

More recently, I also noticed Gemini becoming less reliable. There were occasions when I asked simple questions and received no response at all. Restarting the application was sometimes the only way to get it working again.

Those experiences convinced me to try Claude for this project. Besides building a better personal finance tracker, I also wanted to compare Claude with Gemini and better understand its strengths.

The Workflow

The following workflow will be used to develop my personal finance tracker.

1. Construct a Multi Agent System
2. Building a Personal Finance Tracker
3. Testing and Refinement

What is a Multi Agent System?

In my previous projects, I usually asked a single AI model to handle the entire development process. While this worked for smaller tasks, it became less effective as the project grew. The model had to constantly switch between planning, designing, coding, and testing, making mistakes more likely.

A better approach is to divide the work among specialized agents.

Imagine building a personal finance tracker with a software team. A Software Architect designs the system, a Front-End Developer builds the user interface, a Back-End Developer develops the application logic, and a QA Tester checks for bugs. Each member focuses on a specific responsibility instead of trying to do everything.

A Multi-Agent System follows the same idea. Each agent has a dedicated role, but instead of working in isolation, they can share information and coordinate with one another. This keeps the development process more organized, reduces errors, and allows different parts of the project to progress at the same time.

By default, Claude does not use an agent team to perform tasks. Before development begins, the experimental Agent Teams feature must first be enabled.

CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS=1

Once enabled, Claude can spawn and coordinate multiple agents to work on a task.

Building a Personal Finance Tracker

This project follows the same foundation as my previous Personal Finance Tracker developed with Gemini Antigravity. The complete workflow is described in that article, so I will focus on the changes introduced in this version. The initial prompt is shown below:

<instructions>
  Under the folder "Project - Personal Finance Tracker", 
  I want you to spawn relevant agents working together to built a 
  personal finance tracker based on my requirements stated below. 
  You should use multiple agents to work on this project in a team. 
  For example, agents from sdlc process like software architect, frontend 
  developer, backend developer, QA Tester, and so on
</instructions>
<requirements>
<purpose>
  The purpose of this personal finance tracker is to keep track of 
  the cashflow on every accounts relevant to the user. This should work as 
  a desktop application and mobile application and data is linked between 
  these two apps so that the user can record transactions easily
</purpose>
<pages>
There are in total 5 pages
1. Login Page - User Logins with their username and password. 
  He/she can create an account here 
2. Home Page - A dashboard that gives a general view of the user 
  cashflow in a particular year and month. By default, displayed 
  details should be in the current month, current year. However, 
  the user is able to navigate through different years and months. 
  An option to generate a report of a monthly/yearly cashflow 
  should also be available. 
3. Accounts Page - A page display the current balance of each account 
  where the user is able to add, edit and delete accounts
4. Transactions Page - A page display all the transactions in a month. 
  User is able to add, edit and delete transactions and navigate to see 
  the details of transactions in any month. By default, it should be set 
  to the current month. Moreover, the user is able to upload a details 
  of transactions through a file (photo, pdf, etc...) and the tracker 
  automatically records it.
5. Financial Goals Page - A page displayed all the financial goals the the 
  user desires. These goals can either be tracked manually or linked to an 
  account.
</pages>
<flow>
User opens the application, sees the login page. 
  He logins with his user name and password the 
  proceeds to the remaining 4 pages
</flow>
<design>
  keep it simple, easy to use, intuitively known by the user
</design>
</requirements>

The prompt served as the starting point for the project. Compared with my previous implementation, I made two important changes.

The first was adding a login page. Since a personal finance tracker contains sensitive financial information, restricting access was an important consideration.

The second was structuring the prompt using XML (Extensible Markup Language). By organizing the instructions into clearly defined sections, I found that Claude interpreted the prompt more consistently, reducing mistakes during development.

Implement Claude into Personal Finance Tracker

Although the first version produced satisfactory results, it still relied on manual transaction entry. Since automation was one of the main goals of this project, I designed the following workflow:

My initial idea was to retrieve transaction information directly from personal LINE and phone accounts. However, this would require access to confidential information and could create serious security risks. I therefore decided not to pursue this approach until I better understand how data can be transferred securely between different platforms.

Instead, I integrated the Claude API into the application. This allows the tracker to send uploaded files to Claude and receive categorized transaction data in return. Although API usage comes with additional costs, I believed it offered the most reliable method for processing different file formats and identifying transaction details.

Using the Claude API required an API key from the Anthropic Console. Since API requests are billed according to usage, funds also had to be added to the account before the service could be used.

After completing the setup, I asked Claude to build the feature into the application. For security reasons, I chose to insert the API key manually rather than include it directly in the prompt or generated code. In my application, the key was stored in a separate configuration file specified by the system architecture.

Making a Mobile Application where Data is Synced

While automating transaction recording solved one problem, I also wanted to make the application easier to access. Since users are far more likely to use a phone than a laptop for everyday expense tracking, my initial goal was to make the application available on mobile devices.

To achieve this, I asked Claude to configure the application using the following prompt.

<context>I'm really like your fixes. Let's move on to the last part</context>
<instructions>
  I want you to make this into a stand alone application. 
  Remember our objective that the application should work 
  on desktop and laptop. Now is the time to test that. The 
  most important thing is that the application should run 
  on both platforms and data should be linked
</instructions>
<example>
  If I recorded my transaction on a laptop, that transaction 
  should be displayed on a phone as well
</example>

Claude configured the application so it could be accessed from my phone through my local network, with my laptop acting as the host. Although this approach worked, it required the laptop to remain powered on whenever I wanted to use the application.

After realizing that, I concluded that this defeated the purpose of having a mobile application. Instead, I chose to package the project as a standalone desktop application using Electron, which provided a more practical deployment while preserving the existing application architecture.

Testing and Refinement

The testing phase focused on two areas: functionality and user experience.

The application’s functionality was first evaluated by a QA (Quality Assurance) Tester Agent to identify system bugs, errors, and whether the application satisfied its intended requirements. After reviewing the results and testing the application myself, I found that all major functions performed as expected.

Evaluating the user experience, however, required considerably more time. Unlike functional testing, user experience can only be improved through regular use of the application. Even now, I still believe there are many opportunities to refine the design and workflow.

Several major improvements were introduced as a result of this process.

The first was adding Assets & Liabilities and Portfolio pages. While the application already tracked income and expenses, these alone did not provide a complete picture of a user’s financial health. The Assets & Liabilities page allows users to monitor their overall financial position, while the dedicated Portfolio page presents investment information separately from other accounts, making it easier to review investment performance.

Another improvement was the addition of a Report function. This enables users to generate yearly financial summaries, making it easier to review past performance and identify spending patterns for future financial planning.

Besides these major changes, numerous smaller improvements were made throughout development. The following prompt shows one example of an iterative refinement.

<context>There are a couple of changes I want to make</context>
<instructions>
I want you to put together an agent team to make the following changes. 
Use the agents you already have first. Spawn additional relevant agents 
if needed.
  
<Home Page>
1. Financial Health Section should be at the top
2. Change "Expense & Investment category to "Expense" category only and 
  only display expense records
</Home Page>
  
<Accounts>
1. Accounts should be sorted in categories.
2. Add an option to add a category at user's will as well
3. Add an option to remove category as well. When the user selects this 
  option, if there are bank accounts with those categories, ask the user to 
  change category of relevant bank accounts
</Accounts>
  
<Portfolio>
1. Make the heading tabs bigger and bolder. Right now it's 
  hard to distinguish between heading tabs and all the things invested. 
2. Subtotal and Grand total tab should be bigger and bolder
3. <example> 
  Portfolio, Current Value | Heading SSF (bold and big here)| 
  elements |  Subtotal (bigger and bold)|... Next set of tabs...|
  Grand total (bigger and bold)
    </example>
4. When the user adds a category in holding, he must specify Liquidity 
  of the asset. Liquidity are classified in 2 categories: Low; High
5. Some of the assets are already input into my personal account. 
  I want to classify each category as follows: |SSF:Low| ; 
  |RMF:Low| ; |Stock:High| |Jitta Stock:High|.
6. User is able to edit the details of categories at all times
</Portfolio>
  
<Transactions>
1. When uploading a file, allow the user to choose which account all the 
  transactions should be applied to. This should apply to all accounts in 
  one session when uploading a file.
</Transactions>
  
<Financial Goals>
1. Allow the user an alternate option to link their goals to portfolio (or a 
  combination of portfolio. The user should only be able to choose which 
  "category" of portfolio to base his goals on. 
  <example> 
    Link goals (optional)| SSF| RMF|...|
  </example>
  </Financial Goals>
  
<Assets & Liabilities>
1. The Asset & Liabilities tab at the navigation bar should be after "Home" 
  tab. 
2. The Asset section should be divided into 2 sections Fixed asset and Liquid 
  Asset. 
   1. Fixed Asset are the ones we input in this page in addition. Include all the 
        entries from the portfolio page with "Low" Liquidity. Portfolio details 
        cannot be changed within this page. It should be displayed as categories 
        not the name of holding. The value should be the sum of holdings in 
        that category.
   2. Liquid Asset should display the following details
      1. Savings: Sum of All "Savings" categorized bank accounts
      2. Cash: Sum of all "Current" Categorized bank accounts
      3. High Liquidity Assets from Portfolio page. (with same display format as Low Liquidity assets)
</Assets & Liabilities>
  
</instructions>

Some screenshots of the final application are shown below.

Reflections

Building a second version of my personal finance tracker helped me understand the potential, limitations, and responsibilities of using AI more. More importantly, it reinforced the importance of keeping humans in the loop. While AI can accelerate development, human expertise remains essential for making informed decisions.

The Responsibilities of Using AI

One lesson that stood out throughout this project is that AI can generate solutions, but humans are responsible for deciding whether those solutions should be implemented.

A good example was my decision not to develop a fully synchronized cross-platform application. Although Claude was capable of building it, connecting the application to accounts containing confidential information introduced security concerns that I was not yet confident addressing. Rather than implementing a feature I could not secure properly, I decided to leave it out until I gain a better understanding of secure communication between different platforms.

The same lesson applied when processing financial statements. Uploading complete statements to Claude would expose confidential information to an external service. To reduce this risk, I cropped sensitive information before uploading the documents for transaction categorization. Although this introduced some limitations, it allowed me to use AI more responsibly.

Because of these security considerations, I do not believe the project fully met my original requirements. While the application successfully automated transaction categorization, it was not completely automated. This limitation was not caused by Claude, but by my own lack of knowledge in IT security. As I continue learning, I hope to revisit this part of the project and implement a more secure solution.

Understanding the Model

Another valuable lesson was understanding why the model behaves the way it does. During development, Claude occasionally categorized transactions incorrectly by assigning the wrong year or bank account. I immediately realized that these details had been intentionally cropped out of the uploaded statements to protect my privacy.

Once I understood that, the adjustments were straightforward. I modified the workflow so that the user manually provides the missing information before the transactions are processed. This reminded me that many AI errors are not caused by the model itself, but by the information we choose to provide.

Claude vs. Gemini Antigravity

After completing this project, I found that Claude consistently produced higher-quality results than Gemini Antigravity when developing applications. Most of the improvements I made in Claude focused on refining the user experience and interface rather than fixing technical problems. In contrast, my previous experience with Gemini involved spending considerably more time resolving functional issues before I could begin refining the application.

The trade-off, however, is cost. Claude consumes significantly more tokens, and I could often reach my usage limit after only a few hours of development. Gemini, on the other hand, felt much less restrictive during extended sessions.

Ultimately, the decision comes down to balancing cost and performance. For my workflow, I found the improved performance worth the additional cost.

Conclusion

This project began as a second attempt to improve my personal finance tracker. Looking back, it became much more than that. It gave me the opportunity to explore how AI can assist software development while also teaching me where its limitations lie.

Throughout the project, Claude demonstrated that AI is now capable of developing surprisingly sophisticated applications. From designing interfaces to implementing new features, many tasks that once required extensive coding can now be completed much more efficiently. However, I also came to realize that building a successful application involves far more than simply generating code.

As AI becomes more capable, the role of the developer also changes. Rather than spending all our time writing code, more attention is placed on designing workflows, evaluating AI-generated solutions, understanding security implications, and making informed engineering decisions. Human expertise remains essential to ensure that applications are not only functional, but also practical and secure.

This project also changed the way I think about AI. Instead of treating it as a tool that magically solves problems, I now see it as a capable engineering partner. Like any team member, it performs best when given clear instructions, sufficient information, and thoughtful guidance.

Ultimately, I believe AI will continue to transform software development. The better these models become, the more important it is for us to understand how—and why—we use them. In the end, building this personal finance tracker taught me far more about AI-assisted software engineering than it did about personal finance itself.

Disclosures

AI tools were used to assist with outlining, clarification, and editing suggestions.
All ideas, interpretations, and final writing decisions are my own.

References