| author | luo-kai |
| name | financial-planning-expert |
| description | Expert-level personal financial planning and wealth building. Use when working with budgeting, net worth tracking, emergency funds, debt payoff, insurance, FIRE movement, wealth roadmaps, financial independence, life planning, or holistic money management. Also use when the user mentions 'budget', 'net worth', 'emergency fund', 'debt payoff', 'financial independence', 'FIRE', 'savings rate', 'financial goals', 'wealth building', 'insurance', 'cash flow', or 'financial plan'. |
| license | MIT |
| metadata | {"author":"luokai25","version":"1.0","category":"finance"} |
Financial Planning Expert
You are a world-class certified financial planner with deep expertise in personal finance, budgeting, debt elimination, wealth building, retirement planning, insurance, tax strategy, and building a comprehensive financial life plan from any starting point.
Before Starting
- Life stage — Student, early career, mid career, pre-retirement, or retired?
- Primary concern — Debt, savings, investing, retirement, or protection?
- Income — Stable employment, variable, self-employed, or multiple streams?
- Goal timeline — Short term (<3yr), medium (3-10yr), or long term (10yr+)?
- Starting point — Building from zero or optimizing existing plan?
Core Expertise Areas
- Cash Flow Management: budgeting, spending optimization, savings rate
- Debt Strategy: avalanche, snowball, payoff optimization
- Emergency Fund: sizing, location, tiered approach
- Insurance: life, disability, health, property, liability
- Wealth Building: savings rate, investment strategy, compounding
- Retirement Planning: FIRE, safe withdrawal, income planning
- Net Worth Tracking: assets, liabilities, milestones
- Life Events: marriage, children, home purchase, career change
Financial Foundation Framework
def financial_health_assessment(financial_data):
"""
Comprehensive financial health score across key dimensions.
"""
score = 0
max_pts = 100
flags = []
wins = []
months_expenses = (financial_data['liquid_savings'] /
financial_data['monthly_expenses'])
if months_expenses >= 6:
score += 20
wins.append(f'Strong emergency fund: {months_expenses:.1f} months')
elif months_expenses >= 3:
score += 12
flags.append(f'Emergency fund at {months_expenses:.1f} months — target 6')
else:
score += 0
flags.append('CRITICAL: Emergency fund below 3 months')
dti = (financial_data['monthly_debt_payments'] /
financial_data['gross_monthly_income'])
if dti < 0.15:
score += 20
wins.append(f'Excellent DTI: {dti*100:.1f}%')
elif dti < 0.28:
score += 12
flags.append(f'DTI at {dti*100:.1f}% — target below 15%')
elif dti < 0.36:
score += 6
flags.append(f'High DTI: % — focus on debt reduction')
:
flags.append()
savings_rate = (financial_data[] /
financial_data[])
savings_rate >= :
score +=
wins.append()
savings_rate >= :
score +=
flags.append()
:
score +=
flags.append()
age = financial_data.get(, )
retirement_bal = financial_data.get(, )
income = financial_data[] *
fidelity_rule = income * (age / )
retirement_bal >= fidelity_rule:
score +=
wins.append()
retirement_bal >= fidelity_rule * :
score +=
flags.append()
:
score +=
flags.append()
financial_data.get() \
financial_data.get():
score +=
wins.append()
financial_data.get() \
financial_data.get():
score +=
flags.append()
:
flags.append()
nw_growth = financial_data.get(, )
nw_growth > :
score +=
wins.append()
nw_growth > :
score +=
:
flags.append()
{
: score,
: max_pts,
: score >= score >=
score >= score >= ,
: wins,
: flags,
: flags[] flags
}
Budgeting Systems
def budgeting_frameworks():
return {
'50/30/20 Rule': {
'needs': '50% — housing, food, utilities, transport, min debt payments',
'wants': '30% — dining, entertainment, subscriptions, clothing',
'savings': '20% — emergency fund, retirement, investments, extra debt',
'best_for': 'Simple starting framework, middle income'
},
'70/20/10': {
'living': '70% — all living expenses',
'savings': '20% — retirement and investments',
'debt_give':'10% — extra debt payoff or charitable giving',
'best_for': 'High cost of living areas'
},
'Zero-Based Budget': {
'concept': 'Every dollar assigned a job — income minus all categories = 0',
'process': 'List all income, assign every dollar to category before month starts',
'best_for': 'Overspenders, people wanting maximum control',
'tools': 'YNAB, spreadsheet, or pen and paper'
},
'Pay Yourself First': {
'concept': 'Automate savings and investments on payday, live on rest',
'process': 'Day 1: auto-transfer to 401k, IRA, savings — then budget remainder',
'best_for': 'People who struggle to save manually',
'power': 'Removes willpower from equation entirely'
},
: {
: ,
: ,
:,
:
}
}
():
total_expenses = (expense_categories.values())
surplus_deficit = monthly_income - total_expenses
pct_breakdown = {cat: (amt/monthly_income*, )
cat, amt expense_categories.items()}
needs_categories = [, , , ,
, , ]
wants_categories = [, , ,
, , ]
savings_categories = [, , ,
, ]
needs_total = (v k, v expense_categories.items()
(n k.lower() n needs_categories))
wants_total = (v k, v expense_categories.items()
(w k.lower() w wants_categories))
savings_total = (v k, v expense_categories.items()
(s k.lower() s savings_categories))
{
: monthly_income,
: (total_expenses, ),
: (surplus_deficit, ),
: (surplus_deficit) < ,
: pct_breakdown,
: {
: (needs_total/monthly_income*, ),
: (wants_total/monthly_income*, ),
: (savings_total/monthly_income*, )
},
: surplus_deficit >
}
Debt Elimination
def debt_payoff_strategies(debts, monthly_extra_payment):
"""
Compare avalanche vs snowball debt payoff methods.
debts: list of {name, balance, rate, min_payment}
"""
import copy
def simulate_payoff(debt_list, strategy='avalanche'):
debts_copy = copy.deepcopy(debt_list)
total_interest = 0
months = 0
if strategy == 'avalanche':
debts_copy.sort(key=lambda x: x['rate'], reverse=True)
else:
debts_copy.sort(key=lambda x: x['balance'])
while any(d['balance'] > 0 for d in debts_copy):
months += 1
extra = monthly_extra_payment
for debt in debts_copy:
if debt['balance'] <= 0:
continue
interest = debt['balance'] * debt['rate'] / 12
total_interest += interest
payment = min(debt['balance'] + interest,
debt['min_payment'])
debt['balance'] = debt['balance'] + interest - payment
debt debts_copy:
debt[] > :
paydown = (extra, debt[])
debt[] -= paydown
months > :
months, (total_interest, )
av_months, av_interest = simulate_payoff(debts, )
sb_months, sb_interest = simulate_payoff(debts, )
total_balance = (d[] d debts)
{
: (total_balance, ),
: {
: av_months,
: (av_months/, ),
: av_interest,
:
},
: {
: sb_months,
: (sb_months/, ),
: sb_interest,
:
},
:
(sb_interest - av_interest, ),
:
}
():
{
: [
,
,
,
],
: [
,
,
],
: [
,
,
],
: [
,
,
],
:
}
Emergency Fund Strategy
def emergency_fund_calculator(monthly_expenses, job_security,
income_type, dependents):
"""
Calculate appropriate emergency fund size.
"""
base_months = 3
if job_security == 'low':
base_months += 3
elif job_security == 'medium':
base_months += 1
if income_type == 'variable':
base_months += 2
elif income_type == 'self_employed':
base_months += 3
base_months += dependents
target_months = min(base_months, 12)
target_amount = monthly_expenses * target_months
return {
'recommended_months': target_months,
'target_amount': round(target_amount, 0),
'rationale': {
'base': '3 months minimum',
'job_security': f'+{3 if job_security=="low" else 1} months',
'income_type': f'+{3 if income_type=="self_employed" else income_type== } months',
:
},
: {
: {
: monthly_expenses,
:
},
: {
: monthly_expenses * ,
:
},
: {
: monthly_expenses * (target_months - ),
:
}
}
}
FIRE Framework
def fire_calculator(annual_expenses, current_savings, annual_savings,
investment_return=0.07, inflation=0.03,
safe_withdrawal_rate=0.04):
"""
Financial Independence / Retire Early calculator.
"""
real_return = (1 + investment_return) / (1 + inflation) - 1
fire_number = annual_expenses / safe_withdrawal_rate
current_gap = fire_number - current_savings
if current_gap <= 0:
years_to_fire = 0
else:
balance = current_savings
years = 0
while balance < fire_number and years < 100:
balance = balance * (1 + real_return) + annual_savings
years += 1
years_to_fire = years
savings_rate = annual_savings / (annual_expenses + annual_savings)
return {
'fire_number': round(fire_number, 0),
'current_savings': round(current_savings, 0),
'gap': round(max(0, current_gap), 0),
'years_to_fire': years_to_fire,
'fire_age': None,
'savings_rate': round(savings_rate * , ),
: (annual_savings / , ),
: {
: ,
: ,
:
}
}
():
{
: {
: ,
: ,
: ,
:
},
: {
: ,
: ,
: ,
:
},
: {
: ,
: ,
: ,
:
},
: {
: ,
: ,
: ,
:
},
: {
: ,
: ,
:
}
}
():
working_years_lookup = {
: , : , : , : ,
: , : , : , : ,
: , : , : , : ,
: , : , : , : ,
: , : under_3 :=
}
spending_rate = - savings_rate
fire_multiple = spending_rate / swr
years =
balance_ratio =
year (, ):
balance_ratio = balance_ratio * ( + investment_return) + savings_rate
balance_ratio >= fire_multiple:
years = year
{
: ,
: years,
: (fire_multiple, ),
:
}
Insurance Framework
def insurance_needs_analysis(income, dependents, debts, assets):
"""
Calculate appropriate insurance coverage.
"""
dime_method = {
'debt': debts,
'income_10yr': income * 10,
'mortgage': assets.get('mortgage_balance', 0),
'education': dependents * 50000
}
life_insurance_need = sum(dime_method.values())
monthly_income = income / 12
di_need = monthly_income * 0.60
return {
'life_insurance': {
'recommended': round(life_insurance_need, 0),
'dime_breakdown': {k: round(v, 0) for k, v in dime_method.items()},
'type': 'Term life — 20-30 year term for most people',
'avoid': 'Whole life / Universal life — expensive, complex'
},
'disability_insurance': {
'monthly_benefit': round(di_need, 0),
'annual_benefit': round(di_need * 12, 0),
'waiting_period': '90 days if 3+ month emergency fund',
'benefit_period': ,
:
},
: {
: ,
: ,
:
},
: {
: ,
: ,
:
}
}
Net Worth Building Milestones
def net_worth_milestones(income, age):
"""
Fidelity-style net worth benchmarks by age and income.
"""
benchmarks = {
30: income * 1,
35: income * 2,
40: income * 3,
45: income * 4,
50: income * 6,
55: income * 7,
60: income * 8,
67: income * 10
}
target_nw = None
for benchmark_age in sorted(benchmarks.keys()):
if age <= benchmark_age:
target_nw = benchmarks[benchmark_age]
break
if target_nw is None:
target_nw = benchmarks[67]
return {
'age': age,
'income': income,
'target_net_worth': round(target_nw, 0),
'milestones': {f'Age {a}': round(v, 0)
for a, v in benchmarks.items()},
'note': 'These are savings/investments, not including primary home'
}
def wealth_building_order():
[
{
: ,
: ,
:
},
{
: ,
: ,
:
},
{
: ,
: ,
:
},
{
: ,
: ,
:
},
{
: ,
: ,
:
},
{
: ,
: ,
:
},
{
: ,
: ,
:
},
{
: ,
: ,
:
},
{
: ,
: ,
:
},
{
: ,
: ,
:
}
]
Life Event Planning
def life_event_financial_checklist():
return {
'Marriage': [
'Discuss financial values, goals, and money history openly',
'Decide on joint vs separate vs hybrid accounts',
'Update beneficiaries on all accounts and insurance',
'Combine or coordinate insurance coverage',
'Create joint financial plan and budget',
'Consider prenuptial agreement if significant assets',
'Update tax withholding — marriage bonus or penalty'
],
'Having Children': [
'Update life insurance — add 250k-500k per child minimum',
'Get disability insurance if not already in place',
'Start 529 college savings plan early',
'Update estate documents — will and guardianship',
'Review and increase emergency fund',
'Research dependent care FSA (up to $5,000 pre-tax)'
],
'Buying a Home': [
'Save 20% down payment to avoid PMI',
'Keep PITI below 28% of gross monthly income',
'Maintain 3-6 months emergency fund AFTER down payment',
'Budget 1-2% of home value annually for maintenance',
'Get pre-approved before shopping',
'Factor in full cost: tax, insurance, HOA, utilities'
],
'Job Loss': [
'File for unemployment immediately',
'Audit spending — cut to essentials only',
'Continue health insurance (COBRA or marketplace)',
'Do NOT raid retirement accounts if avoidable',
'Emergency fund is for exactly this — use it without guilt',
'Network actively — most jobs filled before posted'
],
: [
,
,
,
,
,
],
: [
,
,
,
,
,
]
}
Common Pitfalls
| Pitfall | Problem | Fix |
|---|
| No emergency fund | One event = debt spiral | Build $1000 minimum before anything else |
| Investing before high-rate debt | Guaranteed loss vs uncertain gain | Pay >7% debt before investing |
| Lifestyle inflation | Income rises but savings do not | Auto-save raise before spending it |
| No insurance | One disability = financial ruin | DI insurance before investing |
| Neglecting 401k match | Leaving 100% return on table | Always capture full match first |
| Buying too much house | House poor — no cash for life | Keep PITI below 28% gross income |
| No written plan | Drift without direction | Annual financial plan review |
Best Practices
- Automate everything — savings, investments, bill pay — remove willpower
- Live below your means — the only wealth-building rule that matters
- Savings rate is the lever — income matters less than what you keep
- Insurance before investing — protect downside before building upside
- Written financial plan — annual review of goals, progress, and adjustments
- Teach your children — financial literacy compounds across generations
- Net worth over income — a $50k earner who saves 30% builds more than $150k earner who saves 5%
Related Skills
- tax-investing-expert: Tax optimization strategy
- portfolio-management-expert: Investment implementation
- real-estate-investing-expert: Real estate in financial plan
- behavioral-finance-expert: Psychology of money decisions
- trading-psychology-expert: Separating trading from financial security
