Agent skill

Retirement Decumulation

by JoelLewis in JoelLewis/finance_skills

Turn a retirement portfolio into sustainable lifetime income: sequence-of-returns risk, the 4% rule and its assumptions, Guyton-Klinger-style guardrails, RMD calculation from the Uniform Lifetime…

MITAuto-check passedAI & LLM Engineering

Install Retirement Decumulation

skills CLI
$ npx skills add JoelLewis/finance_skills --skill retirement-decumulation -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install JoelLewis/finance_skills retirement-decumulation --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/JoelLewis/finance_skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/wealth-management/skills/retirement-decumulation .claude/skills/retirement-decumulation && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
retirement-decumulation
GitHub stars
206
Token cost
~3.8k tokens
SKILL.md length
1,963 words
Files
2 (incl. scripts)
Skills in repo
91
Repo updated
First seen
Licence
MIT

At a glance

Turn a retirement portfolio into sustainable lifetime income: sequence-of-returns risk, the 4% rule and its assumptions, Guyton-Klinger-style guardrails, RMD calculation from the Uniform Lifetime…

  • The user asks about a safe withdrawal rate
  • SKILL.md covers Core Concepts, Key Formulas, Worked Examples and Common Pitfalls, plus 2 more sections
  • Runs Python scripts from its folder; calls uv and python3
  • Should I claim Social Security

What it does

Retirement Decumulation is an agent skill from JoelLewis/finance_skills. Turn a retirement portfolio into sustainable lifetime income: sequence-of-returns risk, the 4% rule and its assumptions, Guyton-Klinger-style guardrails, RMD calculation from the Uniform Lifetime Table, Social Security claiming math (early reduction, delayed credits, breakeven age, survivor benefits), gap-year bracket-filling with Roth conversions, bucket strategies vs total-return, and SPIA annuitization as longevity insurance. Use when the user asks about a 'safe withdrawal rate', 'when should I claim Social…

Its SKILL.md is about 3.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files, including scripts (for example `scripts/retirement_decumulation.py`).

It sits in AI & LLM Engineering, covering LLM guardrails. The repository describes itself as: Claude Code skill plugins for financial services — 81 skills across 7 domain plugins covering investment management, compliance, advisory practice, trading, and operations. The licence is MIT.

When your agent uses it

  • The user asks about a safe withdrawal rate
  • Should I claim Social Security
  • A guardrails strategy
  • Sequence of returns risk

Example prompts

  • “safe withdrawal rate”
  • “when should I claim Social Security”
  • “guardrails strategy”
  • “/retirement-decumulation”

Requirements

  • Python 3

What it can do on your machine

Read from SKILL.md and the folder at commit 5c498ea. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • uv
    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use uv, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Retirement Decumulation loads about 3.8k tokens when it runs. Until then it costs about 243 tokens; SKILL.md has 1,963 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~243
When it runs · the whole SKILL.md, loaded when a task matches
~3.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from JoelLewis/finance_skills at commit 5c498ea, republished under its MIT licence (© JoelLewis). 1,963 words, ~3,782 tokens.

Download SKILL.mdSave it as .claude/skills/retirement-decumulation/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
retirement-decumulation
description
Turn a retirement portfolio into sustainable lifetime income: sequence-of-returns risk, the 4% rule and its assumptions, Guyton-Klinger-style guardrails, RMD calculation from the Uniform Lifetime Table, Social Security claiming math (early reduction, delayed credits, breakeven age, survivor benefits), gap-year bracket-filling with Roth conversions, bucket strategies vs total-return, and SPIA annuitization as longevity insurance. Use when the user asks about a 'safe withdrawal rate', 'when should I claim Social Security', a 'guardrails strategy', 'sequence of returns risk', or 'how much can I spend in retirement'. Also trigger on RMD amounts or missed-RMD penalties, Social Security breakeven analysis, '4% rule', 'bucket strategy', retirement paycheck design, drawdown or decumulation planning, and whether to buy an annuity. For accumulation-side savings math, see savings-goals; for asset location and tax mechanics, see tax-efficiency.

Retirement Decumulation

Core Concepts

Sequence-of-Returns Risk

Two retirees earning identical average returns can finish with very different wealth if the returns arrive in a different order while money is being withdrawn. Without withdrawals, order is irrelevant — multiplication commutes. With withdrawals, dollars sold after a decline are gone permanently and never participate in the recovery, so poor early returns do disproportionate damage. The danger zone is roughly the five to ten years on either side of the retirement date. Mitigants: flexible spending rules (guardrails), a cash/short-bond buffer, reduced equity exposure near retirement (or a rising equity glide path), and part-time income that lowers the withdrawal rate in early years.

Safe Withdrawal Rate (SWR) Framework

Bengen's 1994 study (extended by the 1998 Trinity study) found that an initial withdrawal of 4% of the portfolio, adjusted for inflation each year thereafter, survived every rolling 30-year US historical period with 50-75% stocks — the "4% rule." Its assumptions are also its criticisms: it relies on US historical returns (an unusually strong market), a fixed 30-year horizon, rigid inflation-adjusted spending with zero flexibility, and it ignores fees and taxes. Longer retirements, high starting valuations, or lower expected returns argue for 3-3.5% initial rates; dynamic rules (guardrails, amortization-based, RMD-style percent-of-balance) support higher initial rates because spending flexes with the portfolio.

Guardrails (Guyton-Klinger-Style Decision Rules)

A concrete dynamic rule set:

  • Initial rate: withdraw, e.g., 5.0% of the starting portfolio in year one.
  • Inflation rule: each year, increase the prior dollar withdrawal by inflation.
  • Guardrails: compute the current withdrawal rate = this year's withdrawal / current portfolio. Set guardrails at plus or minus 20% of the initial rate (for 5.0%: upper 6.0%, lower 4.0%).
  • Capital-preservation rule: if the current rate rises above the upper guardrail, cut the withdrawal 10%.
  • Prosperity rule: if the current rate falls below the lower guardrail, raise the withdrawal 10%.

The full Guyton-Klinger rule set also skips the inflation increase after a negative-return year. The trade-off: a higher starting income than the 4% rule, paid for with variable spending — the retiree must actually take the cuts when triggered.

Required Minimum Distributions (RMDs)

RMDs from tax-deferred accounts begin at age 73 under SECURE 2.0, rising to 75 in 2033 for those born in 1960 or later. Mechanics:

  • RMD = prior December 31 balance / distribution period (divisor) from the IRS Uniform Lifetime Table (use the Joint Life table instead if the sole beneficiary is a spouse more than 10 years younger).
  • Uniform Lifetime Table excerpt (table effective 2022, current as of 2026): age 73 → 26.5, 75 → 24.6, 80 → 20.2, 85 → 16.0, 90 → 12.2.
  • Missed-RMD penalty: 25% excise tax on the shortfall, reduced to 10% if corrected within the correction window (SECURE 2.0; previously 50%).
  • The first RMD can be delayed until April 1 of the year after the first RMD year, but then two RMDs land in one tax year.
  • Roth IRAs have no lifetime RMDs; since 2024, designated Roth 401(k) accounts are also exempt.
  • An RMD is a distribution requirement, not a spending requirement — excess can be reinvested in taxable or given via qualified charitable distribution (QCD, available at age 70 1/2, limit indexed annually — verify the current figure).
Social Security Claiming

Full retirement age (FRA) is 67 for those born in 1960 or later. The adjustment factors are statutory:

  • Early claiming: benefit reduced 5/9 of 1% per month for the first 36 months before FRA, and 5/12 of 1% per month beyond 36. Claiming at 62 with FRA 67 (60 months early): 36 x 5/9% + 24 x 5/12% = 20% + 10% = 30% reduction — the retiree gets 70% of the Primary Insurance Amount (PIA).
  • Delayed retirement credits: 2/3 of 1% per month (8% per year) for each month past FRA, up to age 70. Claiming at 70 with FRA 67: 36 x 2/3% = 24% increase — 124% of PIA.
  • Breakeven: months after the later claim age = B_early x months_delayed / (B_late - B_early), ignoring COLAs and discounting (COLAs apply proportionally to both paths).
  • Survivor benefit: the survivor keeps the larger of the two benefits, so delaying the higher earner's claim is longevity insurance on the second-to-die — breakeven for that decision should use joint life expectancy, which typically favors delay.
  • Claiming before FRA while still working triggers the earnings test (threshold indexed annually — verify the current figure); withheld benefits are restored through recomputation at FRA.
Withdrawal Sequencing and Gap-Year Bracket-Filling

The conventional order — taxable first, then tax-deferred, then Roth — preserves tax-free growth longest (see tax-efficiency for the tax mechanics and asset-location foundations). The decumulation refinement is the gap years: after retiring but before Social Security and RMDs begin, taxable-only withdrawals can leave the ordinary brackets nearly empty. Filling low brackets with partial Roth conversions (or tax-deferred withdrawals) in those years shrinks future RMDs, reduces the survivor's single-filer bracket exposure, and smooths lifetime tax rates — while watching Medicare IRMAA surcharge thresholds (indexed annually) that behave as cliffs. Delaying Social Security to 70 both earns delayed credits and widens the conversion window.

Bucket Strategies vs Total-Return

A bucket strategy holds 1-2 years of spending in cash, several more years in bonds, and the remainder in equities; spending comes from cash, refilled from the growth buckets opportunistically. A total-return approach holds one target allocation and funds withdrawals by rebalancing. Mathematically a maintained bucket structure is close to a fixed allocation with rebalancing discipline; its real value is behavioral — retirees tolerate equity drawdowns better knowing near-term spending is secured. The main failure mode is leaving the refill rules undefined.

Annuitization as Longevity Insurance

A single premium immediate annuity (SPIA) converts an irrevocable premium into lifetime income. Because payments pool longevity risk across annuitants, mortality credits let a SPIA sustain a higher payout rate than a self-insured portfolio at the same confidence level — insurance, not an investment to benchmark against market returns. A floor-and-upside design annuitizes enough (with Social Security) to cover essential expenses and invests the rest for growth. Trade-offs: nominal SPIAs carry inflation risk, liquidity and bequest are surrendered, and payments depend on insurer solvency (state guaranty association limits vary). Deferred income annuities and QLACs push income to advanced ages as a tail-longevity hedge (QLAC premium cap: $200,000 statutory base under SECURE 2.0, indexed annually — verify the current limit).

Key Formulas

FormulaExpressionUse Case
Balance recursion (start-of-year withdrawal)B_t = (B_{t-1} - W_t) x (1 + r_t)Simulate a withdrawal plan / sequence risk
Inflation-adjusted withdrawalW_t = W_1 x (1 + i)^(t-1)Fixed-real spending path
Current withdrawal rateCWR = W / BGuardrail test each year
Guardrail bandsupper = r_0 x 1.20; lower = r_0 x 0.80Trigger thresholds
Guardrail adjustmentW' = W x 0.90 (cut) or W x 1.10 (raise)Capital-preservation / prosperity rules
RMDRMD = balance_Dec31 / divisorRequired minimum distribution
SS early reductionfactor = 1 - [min(m,36) x 5/9 + max(m-36,0) x 5/12]/100Benefit if claimed m months before FRA
SS delayed creditfactor = 1 + m x (2/3)/100Benefit if claimed m months after FRA (to 70)
SS breakevenmonths after late claim = B_e x Δm / (B_l - B_e)Age where delaying pulls ahead

Worked Examples

Show full SKILL.md (812 more words)Show less
Example 1: Sequence-of-returns risk

Given: $1,000,000 portfolio, $50,000 withdrawn at the start of each year (no inflation adjustment for clarity). Sequence A returns: -20%, +10%, +25%. Sequence B: the same returns reversed (+25%, +10%, -20%). Calculate: Ending balances. Solution:

  • No withdrawals: both orderings end at $1,000,000 x 0.80 x 1.10 x 1.25 = $1,100,000 — order is irrelevant.
  • Sequence A (crash first): Y1: (1,000,000 - 50,000) x 0.80 = 760,000. Y2: (760,000 - 50,000) x 1.10 = 781,000. Y3: (781,000 - 50,000) x 1.25 = $913,750.
  • Sequence B (crash last): Y1: 950,000 x 1.25 = 1,187,500. Y2: 1,137,500 x 1.10 = 1,251,250. Y3: 1,201,250 x 0.80 = $961,000.
  • Identical returns, identical withdrawals — the early-crash retiree ends $47,250 poorer. Over a 30-year retirement the same effect determines success or failure.
Example 2: Guardrails adjustment

Given: Retiree starts with $1,000,000 and a 5.0% initial rate ($50,000). Guardrails at plus or minus 20% of 5.0%: upper 6.0%, lower 4.0%. Adjustments are 10%. Calculate: The required action in a bad-market year and a strong-market year. Solution:

  • Capital preservation: after a bad year the portfolio is $780,000; the inflation-adjusted plan (3% inflation) calls for $50,000 x 1.03 = $51,500. Current rate = 51,500 / 780,000 = 6.60% > 6.0% upper guardrail → cut 10%: new withdrawal = 51,500 x 0.90 = $46,350 (rate 5.94%, back inside the bands).
  • Prosperity: later the portfolio reaches $1,400,000 with a planned $52,000 withdrawal. Current rate = 52,000 / 1,400,000 = 3.71% < 4.0% lower guardrail → raise 10%: new withdrawal = 52,000 x 1.10 = $57,200 (rate 4.09%).
Example 3: RMD at age 73

Given: Retiree turns 73 in 2026; the Traditional IRA balance on December 31 of the prior year was $850,000. Uniform Lifetime Table divisor at 73 = 26.5. Calculate: The RMD and the penalty if entirely missed. Solution:

  • RMD = 850,000 / 26.5 = $32,075.47 (about 3.77% of the balance).
  • If entirely missed: 25% excise tax = 32,075.47 x 0.25 = $8,018.87; if corrected within the correction window, 10% = $3,207.55.
Example 4: Social Security claiming breakeven

Given: PIA = $2,000/month at FRA 67 (born 1960 or later). Calculate: Benefits at 62 and 70, and the breakeven ages (ignoring COLA and discounting). Solution:

  • Claim at 62 (60 months early): reduction = 36 x 5/9% + 24 x 5/12% = 30% → $1,400/month.
  • Claim at 70 (36 months delayed): credit = 36 x 2/3% = 24% → $2,480/month.
  • 62 vs 67: head start = 60 x 1,400 = $84,000; monthly gain from waiting = $600. Breakeven = 84,000 / 600 = 140 months after 67 → age 78.7.
  • 67 vs 70: head start = 36 x 2,000 = $72,000; monthly gain = $480. Breakeven = 72,000 / 480 = 150 months after 70 → age 82.5.
  • A single claimant expecting to live past roughly 80-82 gains from delaying; for couples, the higher earner's delay is evaluated on joint life expectancy because of the survivor benefit.

Common Pitfalls

  • Treating the 4% rule as a guarantee rather than a historical US backtest with rigid assumptions — and applying it to 40-year early retirements or high-fee portfolios unadjusted
  • Planning with average returns and ignoring sequence: a Monte Carlo mean hides the early-crash paths that deplete portfolios
  • Adopting guardrails but refusing the spending cut when the capital-preservation rule triggers — the higher initial rate is only safe because of the cuts
  • Treating the RMD as a spending rule: it forces a taxable distribution, not consumption, and it is a floor, not a plan
  • Missing the two-RMDs-in-one-year trap when delaying the first RMD to April 1
  • Claiming Social Security at 62 by default, ignoring the survivor benefit — the higher earner's early claim permanently reduces the widow(er)'s income
  • Running Roth conversions that trip IRMAA surcharge cliffs or push conversion income into the next bracket
  • Leaving bucket refill rules undefined, so the strategy silently drifts to an ad hoc allocation
  • Judging a SPIA as an investment by implied return instead of as longevity insurance priced with mortality credits — or annuitizing so much that liquidity and bequest goals fail

Cross-References

  • savings-goals (wealth-management plugin): the accumulation-side counterpart — the safe withdrawal rate sizes the nest egg target that savings plans aim for
  • tax-efficiency (wealth-management plugin): asset location, Roth conversion breakeven, and the tax mechanics behind withdrawal sequencing and RMDs
  • asset-allocation (wealth-management plugin): glide paths and the equity/bond mix that governs sequence-risk exposure in decumulation
  • historical-risk (wealth-management plugin): drawdown and volatility measures that quantify the return sequences retirees must survive
  • emergency-fund (wealth-management plugin): the cash-reserve discipline that becomes bucket one of a retirement bucket strategy
  • investment-policy (wealth-management plugin): the IPS documents the spending policy, guardrail rules, and rebalancing discipline for decumulation
  • financial-planning-workflow (advisory-practice plugin): decumulation strategy is a core deliverable of the retirement-income phase of a comprehensive plan

Running the script

Run the reference implementation directly:

uv run scripts/retirement_decumulation.py      # PEP 723 header resolves dependencies automatically
python3 scripts/retirement_decumulation.py     # standard library only — no installs needed

A bare run prints a demo covering sequence-of-returns comparison, guardrails adjustments, RMD calculation and penalties, Social Security claiming factors, and breakeven ages. Use --verify to recompute the demo figures and assert they match this skill's worked examples (prints PASS/FAIL, exits nonzero on mismatch), and --help to list the available classes and functions. The file is primarily meant to be imported as a module (from retirement_decumulation import RetirementDecumulation) rather than run standalone.

© JoelLewis, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file (scripts) in plugins/wealth-management/skills/retirement-decumulation of JoelLewis/finance_skills.

  • SKILL.md
  • scripts/retirement_decumulation.py

Open the folder on GitHubat commit 5c498ea

Compare with similar skills

Retirement Decumulation next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Retirement Decumulation compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Retirement Decumulation this skillJoelLewis/finance_skills206—~3.8kAutomated safety check: PassMIT
Aisafetyhotwuyoscar/AISafetyHot-Hub827—~1.4kAutomated safety check: PassCustom licence
ObliteratusRedWoodOG/Hermes-Desktop1775 repos~3.8kAutomated safety check: PassMIT
Lemonade Router Builderamd/skills408—~4kAutomated safety check: PassMIT
Writing Eval Scenariosopen-bias/open-bias143—~1.5kAutomated safety check: PassApache-2.0
Wp Project Triagegambitph/Stackable3513 repos~371Automated safety check: PassGPL-3.0

Similar skills

  • Aisafetyhot

    wuyoscar/AISafetyHot-Hub

    Query AI Safety HOT news, research papers, incidents, hot topics, and daily/weekly/monthly reports through its public read-only MCP service.

    827 GitHub stars~1.4k tokensUpdated today
    AI & LLM EngineeringAuto-check passed
  • Obliteratus

    RedWoodOG/Hermes-Desktop

    Remove refusal behaviors from open-weight LLMs using OBLITERATUS — mechanistic interpretability techniques (diff-in-means, SVD, whitened SVD, LEACE, SAE decomposition, etc.) to excise guardrails…

    177 GitHub starsUsed in 5 repos~3.8k tokens
    AI & LLM EngineeringAuto-check passed
  • Turns a natural-language description of routing intent into a valid Lemonade collection.router policy JSON.

    408 GitHub stars~4k tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed
  • Writing Eval Scenarios

    open-bias/open-bias

    Guide for writing eval conversation JSONs and running them through policy engines

    143 GitHub stars~1.5k tokensUpdated 3 days ago
    AI & LLM EngineeringAuto-check passed
  • Wp Project Triage

    gambitph/Stackable

    A skill your agent uses when you need a deterministic inspection of a WordPress repository (plugin/theme/block theme/WP core/Gutenberg/full site) including tooling/tests/version hints, and a…

    351 GitHub starsUsed in 3 repos~371 tokens
    AI & LLM EngineeringAuto-check passed
  • Wa Guardrails

    aws-samples/sample-well-architected-skills-and-steering

    Official

    Generate preventive Well-Architected guardrails — AWS Config rules, Service Control Policies, permission boundaries, CloudWatch alarms, and IaC policy checks (CDK Aspects, cfn-guard, OPA/Sentinel) —…

    275 GitHub stars~2.8k tokensUpdated 5 days ago
    AI & LLM EngineeringAuto-check passed

More from JoelLewis/finance_skills

All 91 skills in this repo
  • Asset Allocation

    JoelLewis/finance_skills

    Determine how to distribute capital across asset classes using strategic and tactical allocation frameworks.

    206 GitHub stars~2.5k tokensUpdated 2 mo ago
    Auto-check passed
  • Bet Sizing

    JoelLewis/finance_skills

    Determine how much capital to allocate to individual positions within a portfolio.

    206 GitHub stars~2.5k tokensUpdated 2 mo ago
    Auto-check passed
  • Commodities

    JoelLewis/finance_skills

    Analyze commodity markets including futures curve dynamics, roll yield, and supply/demand fundamentals.

    206 GitHub stars~1.9k tokensUpdated 2 mo ago
    Auto-check passed
  • Currencies And Fx

    JoelLewis/finance_skills

    Analyze currency markets, exchange rate mechanics, and FX risk management for international portfolios.

    206 GitHub stars~1.9k tokensUpdated 2 mo ago
    Auto-check passed
  • Debt Management

    JoelLewis/finance_skills

    Provide frameworks for managing and paying off personal debt effectively.

    206 GitHub stars~2.5k tokensUpdated 2 mo ago
    Auto-check passed
  • Diversification

    JoelLewis/finance_skills

    Build diversified portfolios using correlation analysis, efficient frontier construction, and factor-based diversification.

    206 GitHub stars~2.3k tokensUpdated 2 mo ago
    Auto-check passed

Questions about Retirement Decumulation

What does Retirement Decumulation do?

Turn a retirement portfolio into sustainable lifetime income: sequence-of-returns risk, the 4% rule and its assumptions, Guyton-Klinger-style guardrails, RMD calculation from the Uniform Lifetime…. Retirement Decumulation is an agent skill from JoelLewis/finance_skills. Turn a retirement portfolio into sustainable lifetime income: sequence-of-returns risk, the 4% rule and its assumptions, Guyton-Klinger-style guardrails, RMD calculation from the Uniform Lifetime Table, Social Security claiming math (early reduction, delayed credits, breakeven age, survivor benefits), gap-year bracket-filling with Roth conversions, bucket strategies vs total-return, and SPIA annuitization as longevity insurance.

When should I use Retirement Decumulation?

Retirement Decumulation fits situations like: the user asks about a safe withdrawal rate; should I claim Social Security; A guardrails strategy; sequence of returns risk.

How do I install Retirement Decumulation in Claude Code?

Run `npx skills add JoelLewis/finance_skills --skill retirement-decumulation -a claude-code`. Or copy the skill folder (plugins/wealth-management/skills/retirement-decumulation in JoelLewis/finance_skills) into .claude/skills/retirement-decumulation in your project. Claude Code loads it when a task matches its description.

How do I install Retirement Decumulation in Codex?

Run `npx skills add JoelLewis/finance_skills --skill retirement-decumulation -a codex`. Or copy the skill folder (plugins/wealth-management/skills/retirement-decumulation in JoelLewis/finance_skills) into .agents/skills/retirement-decumulation in your project. Codex loads it when a task matches its description.

Can I use Retirement Decumulation in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add JoelLewis/finance_skills --skill retirement-decumulation -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/retirement-decumulation, .gemini/skills/retirement-decumulation, .github/skills/retirement-decumulation and .opencode/skills/retirement-decumulation in your project.

What does Retirement Decumulation need to run?

Going by SKILL.md and its folder, Retirement Decumulation needs Python for the scripts in its folder and the command-line tools its instructions call (uv and python3). Our summary lists: Python 3.

Does Retirement Decumulation access the network?

SKILL.md contains no URLs. Its commands use uv, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Retirement Decumulation safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Retirement Decumulation use?

Retirement Decumulation is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Retirement Decumulation use?

About 3.8k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Retirement Decumulation?

Skills that share tags, products or a category with Retirement Decumulation: Aisafetyhot (wuyoscar/AISafetyHot-Hub, 827 stars), Obliteratus (RedWoodOG/Hermes-Desktop, 177 stars), Lemonade Router Builder (amd/skills, 408 stars) and Writing Eval Scenarios (open-bias/open-bias, 143 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Retirement Decumulation?

JoelLewis (a GitHub user) maintains it in JoelLewis/finance_skills, which has 206 GitHub stars. The repository holds 91 skills in this directory. The repository was last updated on July 18, 2026.

Source: JoelLewis/finance_skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.