The Watchdog Needs a Watchdog: How a Rescue Script Hung Inside Itself
What to do when a system written to rescue you from hangs freezes dead itself? A story about recursive infrastructure paranoia.
What to do when a system written to rescue you from hangs freezes dead itself? A story about recursive infrastructure paranoia.
How we moved logic to a thin client and learned to be friends with GitLab and Bitbucket.
Why we generated graphics on the backend and how we tested RGBA matrices pixel by pixel in CI.
How we forced a modern generator to output a legacy file structure and why routing configuration moved to the core.
Why a strict native parser loses methods, and how we assembled broken C++ code piece by piece.
Why our native C++ parser couldn't parse 'Hello World', and how we built an automatic header discovery system.
How we abandoned a heavy dependency in the cloud and why the Intermediate Representation architecture saved us from rewriting half the project.
How a harmless std::enable_if template trick caused the documentation generator to silently delete classes from the project.
A cautionary tale about why implicit string contracts turn microservices into a distributed monolith.
How a harmless Next.js frontend forced us to battle hosting providers, outdated documentation, and implicit conventions.
How we built a Free-Tier, protected against Abuse loads, and why we chose Clerk over cheap Supabase Auth.
How a harmless configuration file almost became an RCE vector, and why we transitioned to a Zero-Trust architecture.
How we realized that binary distribution would kill our public business, and why we had to fork the product into two branches.
Some code doesn't belong in the main engine forever. We look at why splitting one renderer family into its own private plugin was the answer to a legal question.
How a multi-repository architecture turned into `not our ref` Git traps and forced us to test our core engine in two parallel realities.
After decomposing the monorepo, each of the five repositories got its own CI. Architecturally beautiful, but brutally expensive in GitHub Actions minutes. We spun up our own Windows machine with a single runner for all five—and wrote a watchdog for it that would spectacularly fail less than 24 hours later.
What do you do when your parser generates documentation for a class that a global text search across the entire repository can't find? The story of one false panic.
Victory over the old Doxygen parser turned into a new catastrophe. Temporary directories flooded the disk, and our 'fix' using garbage collection just made things worse.
Every rebuild used to run Doxygen and parse its XML from scratch, even when nothing had changed. Our two-level cache fixed that pain. But the title has a catch: the cache can't make things genuinely fast, because it only knows how to skip work that can be avoided altogether.
The working title was blocked by a registered debugger trademark. We hunted down a short replacement containing the ude substring while simultaneously evaluating sound, SEO potential, and legal safety.
How we untangled a five-project monorepo in one go, and the hard lesson a single Cloudflare token taught us.
No production outages or late-night drama, just a funny and revealing discovery. We ran an autonomous AI audit on our core engine and found a condition that was always, guaranteed, true.
The old universal model stored data as shapeless strings, leading to silent information loss. We rewrote the core with strict types, replacing silent degradation with loud validation errors.
Dead cross-references between handwritten guides and auto-generated API pages quickly explained why managing guides away from Flude, as plain Markdown, was a mistake.
Writing a fast documentation generator is fun. Legalizing it in a hardcore enterprise environment is another story. Here's how we proved Flude's reliability by putting it head-to-head with the old standard.
Corporate infrastructure, colleagues on vacation, and slow tools forced us to build an independent CI/CD pipeline. Here's how AI helped me master YAML in a few evenings.
How a single question from our Infrastructure Lead forced us to rewrite our documentation pipeline, abandon HTML, and accidentally create Flude.