家計AIアドバイザー: 自分株式会社がSupabaseとDartで実装したAI節約提案と複利シミュレーション搭載の家計プランナー
Kakei AI Adviser from Jibun Inc. adds AI savings advice, four-tab budgeting, Supabase ai-assistant reuse, and Dart compound-interest simulations.
What Kakei AI Adviser Is and Why It Matters
自分株式会社 (Jibun Inc.) has expanded its AI-driven life-management effort with a new feature called 家計AIアドバイザー (Kakei AI Adviser). Built as part of an app that consolidates functionality from 21 competing SaaS products — including Notion, Evernote, MoneyForward, and Slack — the Adviser was implemented in response to Amazon Rufus’s recently released “Buy for Me” feature. The addition turns an earlier 128-line stub into a fully realized personal finance module that provides AI-powered, practical saving suggestions and forward-looking asset simulations. For users and developers focused on personal finance tooling, the implementation demonstrates a compact pattern for delivering on-device computations, serverless AI calls, and maintainable analytics storage without expanding backend schema.
Overview of the Four-Tab Budgeting UI
The Kakei AI Adviser exposes a four-tab interface designed to cover the common needs of monthly household financial planning:
- Overview tab: KPI cards summarize total income, total expenses, net balance, and savings rate, alongside a top-five spending breakdown.
- Budget tab: Budget settings are available across 15 predefined categories with progress bars showing spend vs. budget.
- AI Savings Advice tab: An AI analyzes the user’s categorized spending and returns three targeted, practical suggestions for reducing costs.
- Future Simulation tab: A compound-interest calculator simulates asset growth with monthly contributions.
This layout keeps the most actionable items — top-line KPIs and suggested interventions — immediately accessible while separating budgeting configuration and scenario modeling into their own spaces.
How the AI Savings Advice Was Implemented
Rather than creating a new serverless endpoint, the team reused an existing Supabase Edge Function named ai-assistant to provide the Adviser’s AI responses. The frontend assembles a structured prompt that includes the selected month, aggregated totals, and a category-by-category breakdown of spending, then invokes the ai-assistant function with a chat-style payload.
Two implementation decisions stand out in the prompt design. First, the monthly data is passed in a structured, plainly readable format so the model receives context without guesswork. Second, the prompt explicitly constrains the model to return exactly three items and to make them practical and actionable — an instruction intended to keep responses compact and useful rather than speculative. The project’s chosen AI call pattern demonstrates how reusing an existing Edge Function can deliver new features with minimal operational overhead.
Prompt Engineering and Response Handling
The team applied a few practical prompt-engineering techniques to increase answer quality and consistency:
- Provide structured monthly data (income, expense totals, and a per-category breakdown).
- Add an explicit numeric constraint (“3 points only”) to reduce verbosity and focus the output.
- Request concrete, actionable suggestions rather than high-level advice.
Those constraints help the ai-assistant produce compact, user-ready recommendations that fit naturally into the app’s UI and are easy for users to act on.
Compound-Interest Simulation Implemented in Pure Dart
The Future Simulation tab runs a compound-interest model implemented entirely in Dart on the client side. The routine accepts an initial principal, a monthly contribution, an annual return rate, and a number of years, converts the annual rate into a monthly rate, and iterates month by month to compound the balance and add the monthly contribution.
The article’s source includes an example scenario used to illustrate the simulation: an annual return of 5%, a ¥30,000 monthly contribution, a ¥1,000,000 initial principal, and a 20-year horizon produce a projected balance of approximately ¥15,440,000. That projection implies a total principal input of roughly ¥8,200,000 and interest (growth) of about ¥7,240,000, which the developers cite as a concrete demonstration of compounding’s power.
Implementing the simulation in pure Dart keeps the calculation deterministic and visible in the client codebase; it avoids depending on external math libraries and ensures the simulation runs without additional backend calls.
Edge Function Data Pattern and Analytics Storage
For persistent data related to budgeting and expense logging, the project adopts a generic analytics table pattern. Instead of creating multiple dedicated tables for each purpose, the implementation writes different kinds of events into a single app_analytics table and separates purposes via a source column (for example, "budget_plan" or "budget_expense") with a metadata JSON payload that holds month, category, amount, and other context.
That model offers several practical benefits noted by the team:
- Manage varied data types without adding new tables.
- Preserve Supabase Edge Function quota by avoiding extra endpoints or schema changes (the source references preserving quota capacity labeled 94/94).
- Add new fields without a formal schema migration by relying on flexible metadata storage.
The approach trades normalized relational structure for schema agility and operational simplicity, which can be attractive in early-stage feature development or when shipping frequent iterations.
Developer Practices: Linting, Flutter Tips, and Cross-Platform Considerations
Maintaining code quality and low friction for contributors was part of the implementation effort. The team reports keeping both flutter analyze and deno lint free of issues. Two practical developer tips surfaced in the process:
- Trailing-comma rules: Flutter’s analyzer expects trailing commas on multi-line argument lists; adding them avoids linter errors and can improve diff cleanliness.
- DropdownButtonFormField value handling: On Flutter 3.33 and later, the value parameter is deprecated; developers should use initialValue instead to avoid deprecation warnings.
These points are concrete adjustments that help the project meet a zero-issue linting target while keeping the codebase compatible with current Flutter toolchain behavior.
How Kakei AI Adviser Differs from an Established Competitor
The team compared their feature set to an established Japanese personal-finance app, MoneyForward, and highlighted a few differentiators supported by the source material:
- AI savings advice: MoneyForward offers some AI capabilities, while the new Adviser explicitly uses the Claude API for generating saving suggestions.
- Pricing: MoneyForward’s starting price is listed as ¥480/month and up; Jibun Inc.’s implementation is described as completely free.
- Note and task integration: The developer project integrates note and task features alongside finance — a capability the comparison table marks absent in MoneyForward.
- Core features such as monthly budget management, category-based expense breakdowns, and future simulations are present in both products.
The project team frames the combination of free access, AI-driven saving suggestions, integrated notes/tasks, and consolidation of 21 competitor-like features into a single app as the primary competitive angle.
Operational Trade-offs and Reuse Strategies
Reusing the ai-assistant Edge Function and using a single analytics table are both explicit design choices that favor rapid feature rollout and lower operational overhead. Those patterns reduce immediate database schema changes and limit the number of unique serverless endpoints to manage. The trade-off is the need for careful source and metadata conventions to prevent ambiguity when querying or analyzing stored events later.
From a product operations perspective, reusing established serverless functions and retaining a compact analytics schema can accelerate iteration, but teams that adopt this pattern should bake in governance for metadata formats and source naming to keep analytics reliable as the product grows.
Broader Implications for Financial Apps and Developers
The Kakei AI Adviser implementation exemplifies several broader trends in consumer fintech and developer tooling:
- Serverless AI reuse: Reusing an existing AI Edge Function to add features shows how teams can incrementally layer AI capabilities onto existing infrastructure, reducing the cost and time to ship.
- On-device deterministic logic: Implementing financial simulations client-side in Dart keeps the model transparent, reduces latency, and avoids additional backend computation costs.
- Flexible analytics schemas: Storing heterogeneous events in a single table with a source discriminator and JSON metadata supports rapid experimentation, but it raises questions about long-term query performance and governance as usage grows.
- UX-focused AI prompts: Constraining model output to short, practical items (three specific suggestions) improves usability and prevents verbose, less-actionable responses — a useful pattern for other consumer-facing AI features.
For developers, these design choices underline a practical path to add AI to product experiences without building new infrastructure: assemble structured context locally, call a centralized model endpoint for text generation, and persist only what’s necessary in a flexible analytics store.
Product and Business Use Cases
Within the developer’s stated product scope — a single app that consolidates capabilities across many SaaS categories — the family-budgeting module serves multiple roles:
- A retention tool: Regular monthly budgeting and AI advice create recurring utility.
- An acquisition angle: A free finance planner that demonstrates actionable AI suggestions can attract users from paid competitors.
- An integration hub: Because the broader product integrates notes and tasks, budget advice can be surfaced alongside related to-dos or documents, creating workflow synergies for users managing bills, receipts, and financial goals.
These are observed implications grounded in the feature set and product positioning the source describes.
Ending forward-looking paragraph
Moving forward, the implementation pattern shown by Kakei AI Adviser suggests a roadmap that emphasizes iterative AI feature rollouts, client-side deterministic tools, and schema-light analytics for fast experimentation; as the product matures, the team will likely need to balance that agility with stronger metadata governance, more formal analytics schemas for large-scale reporting, and careful monitoring of AI outputs to ensure ongoing usefulness and alignment with user expectations.
