An opinionated field note on the messy, practical, bottom-up AI software revolution.
For decades, enterprise software was a top-down affair. Big platforms were pitched in glossy decks, the C-suite signed seven-figure contracts, and the rest of us learned to live with the… "one size fits all" that fit no one. Cue the workaround Olympics: spreadsheets holding the business together with duct tape, manual data entry marathons, and systems that only talk after a carefully scheduled "coffee"—i.e., a nightly batch job.. "Shadow systems" became the real operating system of the company. (If you've ever spent Friday night reconciling CSVs, you are part of this underground resistance.) The numbers back it up: shadow IT routinely soaks up 30–40% of enterprise tech spend. [Auvik](https://www.auvik.com/franklyit/blog/shadow-it-spend/)
Now something new is happening. AI coding tools—yes, gloriously imperfect—put building power into the hands of the people who actually do the work. This isn't the usual low-code press release. It's a bottom-up shift: knowledge workers and tiny teams stitching together small, purpose-built apps that replace the soul-crushing copy-paste economy. If low-code was the appetizer (Gartner has been yelling that a majority of new apps would use it by 2025), AI-assisted coding is the entrée: faster, more flexible, and closer to how real work happens at the edge. [Quixy](https://quixy.com/blog/gartner-predictions-on-low-code/)
Top-Down vs. Bottom-Up (Or: Decks vs. Doing)
Top-down: Buy a platform. Roll it out. Retrain everyone. Accept compromises as "process." Then spend years negotiating change requests and integration "phases."
Bottom-up: Keep your existing tools. Identify one gnarly, high-friction task. Build a tiny app that kills it. Repeat. You don't need a platform that claims to do everything; you need a queue of small automations that actually do *your* things.
No wonder spreadsheets still run half the planet: they're fast, familiar, and close to the work. The problem isn't that people love chaos; it's that the official systems rarely match reality. (Plenty of teams are still living on "Excel and prayers.") [Diginomica](https://diginomica.com/spreadsheet-still-rules-so-does-spreadsheet-risk)
Will AI replace knowledge workers? Not before it learns your undocumented workflow.
AI can autocomplete code like a champ, but it does not understand your messy, living, context-heavy job. Ask it to rename documents to a precise convention, then match each to a compliance checklist, and you'll watch it hallucinate confidence while quietly mislabeling your future audit. I built that workflow. The human can do it "with eyes closed"; my AI agent required a carefully designed pipeline: parsing rules, file-safe transforms, double checks, exception handling, and logging. *And then more logging.*
That's the point: AI doesn't replace domain understanding; it amplifies it. The people closest to the work know where the dragons live. AI coding lets them prototype, test, and iterate fast—but the judgment stays human.
What Changes (When the Builders Are the Doers)
* Granular value beats "grand solution." Instead of a monolith that promises to fix everything, we ship dozens of tiny fixes that actually stick.
* Workflows get "snapped" together. A small script handles filenames; another verifies formats; another posts status to a dashboard. Each is boring—and together, miraculous.
* Shadow systems go legit. The same ingenuity that kept things afloat moves from brittle spreadsheets into small, governed apps with logs, tests, and versioning. (Yes, you can still keep Excel—just not as your backend.)
* Procurement follows proof. Leaders fund what's already working, not what a brochure promised. (For what it's worth, even big-analyst world acknowledges the citizen-build trend. It's not just vibes.) [Forrester](https://www.forrester.com/blogs/predictions-2024-low-code/)
A Field Note from the Trench
The doc-rename-and-match agent sounded simple. Rename PDFs to `PI_GrantID_DocType_v01.pdf`, then match each to a checklist row. In practice:
* File names arrive in every dialect known to humankind.
* "Same" document appears as four slightly different uploads.
* The checklist has conditional rules ("If budget > $250k, also include X").
* People fix things at 11:56 PM, creating edge cases you couldn't invent on purpose.
My agent ended up with a pipeline: extract → normalize → classify → rename → match → verify → report. Each step is tiny and testable, each with guardrails for "this looks off, please review." Did AI help? Absolutely—drafting classifiers, writing boilerplate, generating tests. Did it replace me? Absolutely not. It made me faster, not optional.
How to Start Your Bottom-Up AI Revolution (One Task at a Time)
1. Pick one high-pain task. Think "hourly annoyance," not "digital transformation."
2. Write the happy path as a checklist. If you can't describe it, you can't automate it.
3. Automate the boring thirds first. Naming, formatting, simple validations. Ship that win.
4. Instrument everything. Logs, dry runs, preview modes. (Welcome to the "trust, but verify" era.)
5. Design for rollback. Your future self will thank you.
6. Iterate weekly. A little reliability, then a little reach. Repeat.
Why This Time Is Different
Low-code promised "anyone can build." The reality: many did, and then IT spent years cleaning up. AI coding shifts the center of gravity again—not because it's magic, but because it reduces the distance between idea and working prototype. And that makes it economically rational for small teams to tackle their own pain… then share what works. Meanwhile, the shadow IT iceberg is a reminder of how much value still sits outside official systems. [Auvik](https://www.auvik.com/franklyit/blog/shadow-it-statistics/)
This isn't a story about replacing people. It's a story about replacing drudgery—and letting the people who actually know the work shape the tools. The future isn't one giant platform; it's a lattice of small, durable automations that reflect how your team really operates.
One task at a time. Eyes open. Logs on. And if your agent swears it "definitely matched all 63 documents," make it show you the receipts.
Sources
* Shadow IT spend (30–40%+). Round-up citing Gartner's 30–40% and Everest Group's "50%+" estimate. [Auvik](https://www.auvik.com/franklyit/blog/shadow-it-spend/)
* Spreadsheets still run the business. Why "shadow systems" (especially spreadsheets) persist in real workflows. [Diginomica](https://diginomica.com/spreadsheet-still-rules-so-does-spreadsheet-risk)
* Spreadsheet risk (context). Overview of why spreadsheets create operational risk when used as systems. [Oracle](https://www.oracle.com/cx/finance/financial-close/spreadsheet-risk/)
* Citizen/low-code growth (Forrester). 2024 global snapshot of enterprise low-code adoption. [Forrester](https://www.forrester.com/blogs/predictions-2024-low-code/)
* Gartner prediction (widely cited). "~70% of new apps will use low-/no-code by 2025" (secondary summaries of the Gartner forecast). [AIMultiple](https://research.aimultiple.com/low-code-statistics/)