Is PiggySize AI slop? An honest answer

Short answer: AI helped build PiggySize, and a human engineer designed, reviewed, tested, and shipped every part of it. "AI slop" usually means content or software generated in bulk and pushed out without anyone checking it. That's the opposite of how this was built — and this page shows the receipts, so you can judge for yourself.

What people usually mean by "AI slop"

The phrase is doing a lot of work, so it's worth separating the real concerns from the vibe. When someone asks if a site is AI slop, they're usually worried about one of these:

• Content that's confidently wrong — articles that invent statistics, cite studies that don't exist, or repeat generic advice with no substance.
• Software that's half-broken — buttons that do nothing, math that's subtly off, pages that fall apart on a phone.
• Security nobody thought about — a data leak waiting to happen because no one asked "what if a different user tries this?"
• Nobody home — no real person behind it, no one to fix a bug, gone in six months.

Those are fair worries. They're also all testable. So the more useful question isn't "was AI involved," it's: who checked the work, and how?

How PiggySize was actually built

PiggySize is built by a working software engineer using AI the way a carpenter uses a nail gun: it makes the work faster, it doesn't decide where the house goes.

In practice that means:

• A human writes the spec. What a feature does, what it must never do, how it behaves when things go wrong. AI doesn't get to invent product decisions.
• A human reviews every change. Code that isn't understood doesn't ship. If a generated solution is clever but fragile, it gets thrown away and redone.
• Everything is checked automatically before it goes live. An automated test suite runs on every change — including tests that drive a real browser, click through real flows, and fail the release if a page breaks.
• Security is reviewed as its own step, repeatedly, by people actively trying to break it — not assumed because the code looks fine.
• Mistakes get fixed at the root. When a bug is found, the same pattern is searched for everywhere else in the codebase and fixed there too.

"Couldn't I just build this myself with AI?"

Honestly? You can build something in a weekend. Modern AI tools are genuinely remarkable, and a working budget tracker is a real weekend project now. That part isn't hype.

What a weekend doesn't get you is the part that makes financial software trustworthy. Here's what that actually looks like.

Retirement math is not one formula

Most people picture a retirement calculator as compound interest in a loop. The real thing has to model, all interacting at once:

• Required minimum distributions — and cap them at what's actually in the account
• Withdrawal ordering across taxable, pre-tax, and Roth accounts, because the order changes your lifetime tax bill
• Roth conversions, federal and state taxes, and how each year's withdrawals push you into different brackets
• Social Security claiming age, spousal timing, and how benefits are taxed
• Pensions and annuities starting at different ages than retirement itself
• Real estate — property tax inflation, downsizing, switching to rent
• Healthcare, HSAs, and long-term care costs that arrive late and hit hard
• Two people retiring at different ages, with contributions that must stop for one and continue for the other
• Monte Carlo simulation, so the answer is a range of outcomes rather than one falsely confident number

Each of those is its own body of rules, and they all feed each other — change the withdrawal order and the tax bill moves, which moves the Social Security math, which moves the required withdrawal. In PiggySize the tests written to prove that engine correct are larger than the engine itself. That ratio is the point: most of the work is proving the answer is right, not producing an answer.

The bugs are invisible until you go looking

These are real bugs that were caught and fixed here, each now pinned by its own test:

• Money appearing from nowhere. A forced withdrawal larger than the account balance wasn't capped, so the simulation quietly created dollars that didn't exist. Every total downstream was wrong — and every total still looked perfectly plausible.
• Contributions that never stopped. When one spouse retired earlier than the other, their paycheck contributions kept flowing into the plan for years afterward. The projection just looked optimistic.
• Rental income counted as salary. Which quietly inflated retirement contributions that are only allowed on earned income.

None of those crash. None of them show an error. They produce a confident, clean-looking number that is simply wrong — and if you don't already know that RMDs are capped by the balance, or that contributions are tied to earned income, you will never think to check.

Security is where inexperience actually bites

Getting your own math wrong is bad. Leaking data is worse. This is what dedicated security review exists to catch — because none of it looks like a bug:

• Permission rules that don't enforce what the settings screen shows. The toggle says one thing, the code checks another, and the app behaves exactly as written. What's written is wrong.
• Database rules that check the wrong thing — verifying who owns a record when the real risk is what values get written into it. It reads correctly. It passes tests. It isn't safe.
• Exports that can run commands. Text starting with = in a spreadsheet file is treated as a formula by Excel — an attack that has nothing to do with your app code and everything to do with knowing it exists.
• Endpoints that are individually fine and collectively a leak. One screen filters correctly while a second route answers the same question without filtering.

PiggySize is audited against this class of problem repeatedly, by someone actively trying to break it, rather than assumed safe because the code looks reasonable. That's the difference that matters: you cannot ask AI to warn you about a risk you don't know to ask about.

And the parts nobody thinks about

Underneath the features sits a long history of database migrations — each one a schema change that has to apply cleanly to live data, in order, without downtime or data loss, with a way back if it fails. Plus rate limiting, session handling, payment edge cases, email deliverability, accessibility, and a browser extension that has to pass store review.

Here's a favorite lesson from this project: a fully green test suite once coexisted with every single production deploy failing for two hours. The tests were right. They just weren't testing the thing that was broken. Knowing that gap exists — and building a check for it — is not something a chatbot volunteers.

The counterintuitive part: AI made the boring work possible

Here's what most "AI slop" takes miss. The parts of software that make it trustworthy aren't the fun parts. They're the tedious parts — and tedious parts are exactly what small teams skip when they're short on time.

Things like:

• Automated tests for every calculator and every screen, so a change to one feature can't silently break another.
• Type checking across the entire codebase, with a rule that the number of allowed errors can only ever go down.
• Accessibility work — keyboard navigation, screen-reader labels, color contrast — which is genuinely dull and almost always deferred.
• Performance budgets, so pages stay fast on a mid-range phone on a bad connection.
• The ugly edge cases: what happens at $0, at a negative net worth, when someone pastes an absurd number into a field.

A human alone weighs each of those against shipping the next feature. AI doesn't get bored, doesn't get impatient at 11pm, and doesn't quietly decide the edge case "probably won't happen." So the honest claim isn't "AI made this better than a human could." It's: AI removed the excuse for skipping the unglamorous work that separates solid software from flaky software.

What we don't claim

Being honest means naming the limits too.

• No software is bug-free. PiggySize has bugs — the calculator one above was found while writing this very page. When you find one, it gets fixed, and usually a test gets added so it can't come back.
• PiggySize is not financial advice. It doesn't recommend investments, doesn't tell you what to do with your money, and doesn't pretend to know your situation. It shows you your own numbers and lets you model what-ifs.
• Projections are models, not predictions. Every projection rests on assumptions, so PiggySize shows you those assumptions on screen and lets you change them, instead of handing you one confident number.
• AI features are labeled. Where a feature uses AI, that's stated. AI output is a starting point for your thinking, not a verdict on your finances.

About the articles on this blog

Since you're reading one: many posts here start as an AI-assisted draft, then get edited and fact-checked by a person before publishing. The rules those drafts are written against are strict, and they're the same rules a human author follows here:

• Every statistic must trace to a named, real source with a year. If a number can't be attributed, it doesn't get stated as a fact — it gets reworded or cut. Invented citations are the fastest way to become slop.
• Teach the topic completely, even if you never sign up. A post that only makes sense as a sales pitch has failed.
• No guarantees, no "you should," no hyped returns. Ranges and honest uncertainty instead of false precision.
• Plain language, with every bit of jargon defined the first time it appears.

If you ever find a claim on this blog you can't verify, that's a bug too. Tell us and it gets corrected.

How to check for yourself (5 minutes, no signup)

Don't take any of this on faith. Slop is easy to spot if you poke at it:

1. Use a calculator and try to break it. Enter zero. Enter a negative number. Paste something absurd. Slop breaks, shows NaN, or gives a confidently wrong answer. (Yes — please actually try. That's how the bug above was found.)
2. Check the math against a source you trust. Run the same numbers through a bank's or a government site's calculator and compare.
3. Open it on your phone. Bulk-generated sites tend to fall apart at small widths.
4. Read a blog post and chase a citation. Search the study or survey it names. If it exists and says what the post says it says, that's a real signal.
5. Read the privacy policy and terms. Look for specifics about what's collected and why. Vagueness there is more telling than anything on the homepage.
6. Look for signs of maintenance — recent posts, a changelog, working support. Abandoned projects stop moving.

The bottom line

"Was AI used?" is becoming about as useful a question as "was a spreadsheet used?" Nearly all software will be built with AI assistance soon, and plenty of it will be junk — but so was plenty of hand-written software.

What separates the two is whether someone who knows what they're doing owned the result: specified it, reviewed it, tested it, secured it, and fixes it when it breaks. That's the claim being made here. The checks above exist so you don't have to take it on trust.