AI at Work
Plain-language stories about the small breakdowns that waste time, hide important work, or make a process hard to trust. Each story shows what changed, where AI can help, and where people still need to make the call. Where useful, you can also copy a practical prompt into the AI assistant you already use.
Look for the work that has become repetitive, invisible, hard to hand off, or difficult to check. The goal is not to add AI everywhere. It is to make one real workflow easier to run.
Each story can lead to the underlying Build Log, with the technical decisions, failures, and safeguards behind the result.
Stories marked with a prompt include a copyable way to ask an AI assistant for a careful review. You keep control of the facts, the decisions, and every change.
Paired lenses
Repeated explanations are a sign that important context is trapped in memory instead of being available where the work begins.
Technical field noteWriting an AI_CONTEXT.md So Your Assistant Stops Rediscovering Your CodebaseOpen the technical lens ↗A convenient default can quietly make a choice for people long after the situation has changed.
Technical field noteGetAccountFilter and the Case for an Explicit Context You Can OverrideOpen the technical lens ↗Repeated fixes can be a sign that the work has outgrown the way it is being presented. Before improving another detail, ask whether the process still fits the task people need to complete.
Technical field noteThe Create-Event Dialog Had to DieOpen the technical lens ↗A repeated correction is not always quality control. It can be a quiet signal that the process or tool is producing an unreliable result.
Technical field noteThe workflow broke in the glue code, not the AIOpen the technical lens ↗A recommendation becomes risky when it can be mistaken for work that someone has already approved or accepted.
Technical field noteAI Can Only Say "Suggested": The Invariant That Keeps AI Triage From Flooding Your TeamOpen the technical lens ↗Find the work problem you recognize
These paths are not categories for AI tools. They are common work situations. Choose the one that sounds familiar, then follow the practical stories and their technical field notes as far as you need.
Start here when a status, save, metric, or AI output looks finished but the real outcome still needs evidence.
Start by asking: Ask what has actually been observed, what is still assumed, and what would count as proof.
Start here when important work lives in comments, memory, or scattered places instead of a shared home.
Start by asking: Ask what the next person would need to know without becoming a detective.
Start here when a suggestion, dashboard, or convenient default is making a consequential choice less visible.
Start by asking: Ask which decision still belongs to a person and what evidence should be visible before it is made.
Start here when recurring manual fixes, surface complaints, or unclear instructions point to a wider workflow problem.
Start by asking: Ask what repeats, where the path really fails, and which small change would make the work easier to run.
Start here when a release, cleanup, or improvement needs a clear outcome, not only a completed-looking step.
Start by asking: Ask what should happen next, who checks it, and what result proves that the work actually landed.
Start here when first use, navigation, or a scattered model makes a simple next step harder than it should be.
Start by asking: Ask what a person needs at the precise moment they begin, arrive, or choose where work belongs.
Explore all six reader paths →
For a live workflow, not for every reader
These stories can help you diagnose a pattern. If you need to decide what to repair, what AI can safely do, and whether a small pilot is worth proving, DXDEV offers a fixed-scope assessment for one workflow your team owns.
USD 4,500, fixed-scope. One workflow, one clear decision, and no artificial scarcity.
Stories about making work easier to run
The same crash alert kept firing, over and over, until it stopped meaning anything. The causes underneath it turned out to be three ordinary things wearing different disguises.
The routine meant to catch broken accounts only ever looked at the ones already flagged as broken. One bug quietly un-flagged them first.
Paired technical field noteWhen Operations Can Fail Partway: Use Rollback, Not Error HandlingA guard built to warn us the moment free usage ended stayed silent through two real charges, for two different reasons.
Paired technical field noteThe Spend Guard That Was Timezone-Blind and Let Real Charges ThroughA new call to action went live for everyone. It looked right until I signed in as a customer and saw a trial offer. Four releases and one reverted rewrite later, customers see nothing there, on purpose.
Paired technical field noteA Front Door That Only Worked If You'd Never Been HereA working login proves the door opens. It does not prove anyone is on the other side to answer when something urgent comes through.
Paired technical field noteA Working Credential Is Not the Same as a Working AgentWhen someone says the notes were saved but the next person cannot find them, the handoff is not complete. Treat a readable shared record as the proof.
Paired technical field noteA Saved Reply Is Not a Stored RecordA tool can be well built, pass its demo, and still never do its job on a single real case afterward. The only proof is checking a recent one.
Paired technical field noteFive Bugs Deep: The Auto-Organiser That Had Never Once ExecutedA teammate's assistant kept erroring because its instructions were out of date. The right fix was a message asking permission, not a silent patch to someone else's work.
Paired technical field noteOnboarding an Agent on a Machine You Do Not OwnMy partner and I ran a whole venture out of a chat channel. The plan was never missing. It was just sitting there unshaped, and the answer to 'where are we' was always to scroll.
Paired technical field noteThe Conversation Is the Backlog: Feeding a Task Engine From DiscordA small server migration tested clean, then failed completely the next morning with nothing changed. I'd already written the guardrail for this exact problem, for something much bigger.
Paired technical field noteWhen Infrastructure Changes Faster Than DNSA dashboard count got filed as an emergency because it sat next to a timestamp from today. The count itself was two years old.
Paired technical field noteThe Urgent Bug Report That Was Two Years OldI built a check to make sure a safety setting was always turned on. The first version passed even after I removed the setting, because a comment nearby still mentioned it.
Paired technical field noteI Asked for JSON and Got My Own Footer BackA watchdog built to catch a real problem judged everything by one signal. Forty-four of its 55 pages were nothing. The other eleven, wearing the identical label, were a real emergency.
Paired technical field note956 Certificates Could Only Renew If a Customer Did Something. The Watchdog Then Paged 55 Times and Buried Eleven Real Outages.An automated task needed a throwaway test account, made itself one through the real signup form, and then reported that nothing had been created. Two real accounts said otherwise.
Paired technical field noteThe Test That Left Real Accounts BehindI reread a comment I'd written myself and had to stop and decode it. The problem wasn't the writing. It was that I'd written for the wrong reader.
Paired technical field noteSurface Format Matches AudienceA pile of things flagged for review only counts as trustworthy once it's empty. Run by too few people, that rule turns into a second job nobody can finish.
Paired technical field noteThe Reconciliation Queue TrapA maintenance plan said about three minutes, then twenty to forty-five. The real run was two restarts of about two minutes each, and the second one was not in the plan at all.
Paired technical field noteThe Runbook Said Three MinutesA months-old figure went into a new planning document as settled truth. It read exactly as current as a number checked five minutes earlier, until someone actually checked.
Paired technical field noteThe Number I Wrote Down Was Already WrongBefore undoing a change on a live system, I flipped on a mode built to check the plan without running it. It ran the plan anyway.
Paired technical field noteThe Safety Check I Trusted Wasn't OneA customer's save failed with an error on screen. Our own records had nothing matching it. The missing record turned out to be the answer, not a dead end.
Paired technical field noteThe Silence in the Log Was the BugTwo founders had a plan, a shared folder, and a lot of good conversation. None of that answered whether the thing they were building actually worked yet.
Paired technical field noteA Venture From Brainstorm to Live Domain in Two WeeksA scheduled AI job burned most of a day's budget checking for news, then a second job on the same account burned more just to fail and reveal the account was already empty.
Paired technical field noteWhen Your Daily Agent Ran Out of Quota, Pivot to Event-DrivenFive of our ten shared work slots looked full because the tracking board said so. Three of those five were actually free, and the board didn't know it.
Paired technical field noteCoordinating Ten Agents That Share One CodebaseA rulebook promised a partner's access would be controlled by a real, working safeguard. The safeguard was real. It just had nothing to do with the system being shared.
A nightly check kept hitting its one-hour limit and stopping without a word. The screen showed results for the domains it reached, which looked exactly like full coverage of all 205.
Paired technical field noteThe Scan That Stopped Scanning: When Timeouts Hide Incomplete CoverageAn automated checkpoint blocked a finished piece of work as unsafe. The work was fine. The checkpoint had confused two different things that happened to share a label.
Paired technical field noteWhen Your Own Guardrail Lies to YouA single slow response paged the whole team as if the site were down. It wasn't. The next check was perfectly normal.
Paired technical field noteAsymmetric Alerting: Stop Paging on Transient BlipsA recurring-failure count dropped by thirteen between two runs. Nothing in the underlying work had actually changed. The counter had been wrong the whole time.
Paired technical field noteWhen Your Own Audit Tool Becomes the Source of MisinformationA login system checked out clean on every test that could run without touching the real thing. The first real signup found the one number that mattered.
Paired technical field noteI Picked 150,000 Password Hash Iterations and the Platform Said NoWeeks of assuming a dropped connection was killing my work, until the system's own record pointed at something I was doing to myself.
Paired technical field noteMy Sessions Kept Dying and I Blamed the Wrong ThingA website attack became manageable only after I moved the first line of defense away from the machine being overwhelmed.
Paired technical field noteThe bot swarms moved faster than my firewall rulesA late-night look at four years of saved changes showed that the biggest change was not simply getting more done.
Paired technical field noteSix months of AI, measured in git instead of vibesA warning about aging machines became a reason to move carefully without turning an urgent repair risk into a costly rewrite.
Paired technical field noteOur servers are too old to fix, and we still ship classic ASP on purposeA change that took days in the systems we controlled became months of waiting for thousands of people to change one small setting.
Paired technical field noteMigrating thousands of customer domains to a layer above the serverI stopped treating browser trouble as a bad setting and built a way for several jobs to share it without stepping on each other.
Paired technical field noteI stopped babysitting the browser, then had to build the part that was missingA memory can sit safely in a file and still be missing when the system needs it.
Paired technical field noteThe 200-Line Lie: Why My Agent Kept Forgetting My GoalsA process can look broken when the real problem is a bad assumption about the information underneath it. A small diagnostic can prevent an automated fix from making the situation worse.
Paired technical field noteBefore you repair data, build the diagnosticA reviewer answered the hardest questions correctly in a ticket comment instead of the structured tool built for exactly that job. The tool wasn't broken. It just wasn't where the answer was already happening.
Paired technical field noteBuilt the Review Tool, Then Told the Other Dev to Skip ItOne reviewer checked a change against a list of known risks and it passed. A second reviewer asked a different question and found quiet mistakes the list was never built to catch.
Paired technical field noteThe Internal Review Said Clean. A Second Pass Found Six Real Bugs.A customer paid on time and their account still showed expired. The system had no error to point to, because the message telling it a payment happened had never arrived at all.
Paired technical field noteSilent Integration Failures: When Your Webhooks Disappear Without WarningAt 8:38 AM a session appeared on my command board that I did not start. My own helper had created it, nothing on it said so, and by the end of the day 5 of 18 sessions were the same kind.
Paired technical field noteYour Agent Dashboard Can't Tell Which Sessions You StartedBreaking 355 past work sessions into 1,748 separately tracked pieces of work replaced a weekly habit of trying to remember what sounded worth reporting.
Paired technical field noteBreaking Every Chat Into Trackable UnitsEvery test passed on a change to a live queue. Instead of shipping it, a second, independent reviewer was asked to attack the tests rather than admire them, and found the real gap wasn't in the code.
Paired technical field note34/34 Green Tests, Then I Made a Second AI Argue Against My Own SuiteAn automated system's text-message callback had a duplicate-send risk hiding in the gap between the message provider accepting a send and our own system recording it as complete.
Paired technical field noteHow Autonomous Jobs Notify HumansA publication rule enforced only by manual review kept missing the same categories of private text. A short scanner found one already sitting live.
Paired technical field noteI Built a Linter That Scans for My Own NameAn internal tool ran at a normal pace and tripped the same rule built to catch scrapers and credential-stuffing bots, locking staff out of their own admin panel.
Paired technical field noteWhen Your Own Firewall Locks You OutA six-hour migration moved 25 brand domains with no downtime. The bigger find was a health monitor that had been checking the wrong addresses the whole time, unrelated to the move itself.
Paired technical field noteZero-Downtime Domain Migration Without an Ops TeamA migration was marked done and trusted for four days. The tool that verified it was asking the same system it was supposed to be checking, so it could only ever confirm what that system already believed.
Paired technical field noteWhy Your Verification Tool Is Confidently WrongA tool that could only create a small, sandboxed file was labeled with an accurate, generic warning. One AI assistant handled that label fine. Another one treated it as a reason to refuse the tool entirely.
Paired technical field noteThe Same MCP Tool Had to Lie About Itself to Different AI ClientsAn 87-hour push to make our own writing readable by AI crawlers briefly shipped a real name where a pseudonym belonged, and the same infrastructure that made the site easier to reach made that mistake harder to fully take back.
Paired technical field noteBuilding a Blog Your Agents Can Actually ReadA migrated domain sat unfinished for thirteen hours with an empty error box. The record I had already checked off was the thing that had gone stale.
Paired technical field noteThe Certificate Reported No Error for Thirteen HoursA checklist item read 'rollback exercised once for real'. When I finally ran it, three of the test sites I expected to use had already lost the thing that makes going back possible.
Paired technical field noteWe Had a Rollback Plan for Moving Customer Domains. Nobody Had Ever Run It.Calling a task low risk does not create the access, evidence, or reversal path needed to perform it safely.
Paired technical field noteCapability Gates Beat Risk Labels in Autonomous Agent DesignA permission left unset was quietly treated as full access instead of no access. The fix wasn't a smarter default, it was refusing to allow any unset case at all.
Paired technical field noteThe Silent Default That Let My Agents Skip Every Permission CheckA password that had just worked minutes earlier came back rejected somewhere else, with two systems giving two different error messages for what turned out to be one cause. The choice afterward was between a fast fix and a complete one, and both cost something.
Paired technical field noteThe stale credential that failed two different code paths at onceA useful shortcut seemed to be working until the session records showed that the computer had never been able to find it.
Paired technical field notertk Wasn't Broken, It Was Unreachable: How I Found 366 Silent Failures in My AI Agent SessionsA request for a more distinctive title was solved by revealing a trusted option that already existed instead of building a separate one.
Paired technical field noteBefore adding a new option, ask whether the existing one is almost rightA repeated pattern across workspaces looked like harmless clutter until I treated it as a question instead of a deletion task.
Paired technical field noteUniform state is a clue, not a conclusionA message can warn people about a conflict without preventing the conflict from damaging someone else’s work.
Paired technical field noteA warning is not a guard: make conflicting work stop before it overwritesA website check looked reassuring until removing an old setting revealed that it was answering the whole time.
Paired technical field noteThe False 200: When Removing a Binding Reveals Your Verification Was LyingA task list can create stress long after its labels stop reflecting what is actually happening. Before asking AI to prioritize work, make sure the underlying signals still mean what you think they mean.
Paired technical field noteWhen a work queue stops telling the truthTrust increases when a record can show that it changed, when it changed, and where someone should look to understand the change.
Paired technical field noteA hash-chained manifest makes archive changes visibleA small page looked healthy but gave people the wrong answer because a copied shortcut had lost a safety step.
Paired technical field noteThe legacy server-variable bug that printed `undefined` instead of a valueA dry run can create false confidence when it exercises a cleaner or different path than the action it claims to preview.
Paired technical field noteA dry run is only useful when it checks the same things as applyA tidy-looking work item can hide independent fixes that block one another and blur accountability.
Paired technical field noteOne mixed QA ticket can slow down every independent fixA status label can stay still while the work beneath it changes. That makes a simple summary misleading for everyone relying on it.
Paired technical field noteThe epic said "Not started" while six tickets shipped under it: reading progress past a stale status tableA full system drive led to a simple fix: give browser work a fixed home, a cleanup plan, and room away from the drive the computer needs.
Paired technical field noteMy agents quietly hoarded 48 GB of Chrome profiles until the machine frozeA nearly full computer drive turned a simple folder move into a lesson about stopping live work before changing where it is stored.
Paired technical field noteYou can't repoint a junction under live file handles (why I had to stage the .claude move)A small edit-box mistake turned normal quotation marks into text that grew more broken with every save.
Paired technical field noteEdit a label, get " back: the HTML-entity round-trip bugA shared record got addressed by a slot number instead of a name, and a real notice got overwritten before anyone read it. The evidence I checked in the next six minutes is what turned a scary-looking mistake into a non-event.
Paired technical field noteI overwrote a live production mailer because I assumed an ID was freeA status update can create confidence before the intended result has actually happened. Before calling work complete, make sure someone can check the outcome that matters.
Paired technical field noteThe release said LIVE. The code was not.A browser kept choosing a road my computer could not use, so ordinary network tests looked healthy while pages stalled.
Paired technical field note\"My internet feels unstable\" was a half-disabled IPv6 stack, not the ISPWhen work happens in parallel, a larger activity number can look impressive without showing whether the work was useful, reviewed, or ready for the people affected by it.
Paired technical field noteParallel Work Needs More Than a ClockA small network-setting change turned a familiar local shortcut into a ten-second wait on every page load.
Paired technical field noteThe IPv6 fix bit back: how localhost resolving to ::1 quietly broke a three-hop proxy chainA busy screen can show every recent activity and still leave people unsure where to start. A useful work view puts the next point of human attention ahead of the activity log.
Paired technical field noteThe dashboard got better the moment I stopped centering sessionsThe first helpful step is often helping someone see the right information clearly before anyone gives a tool permission to change it.
Paired technical field noteThe useful part of a vault portal was admitting the ai should read, not writeA separate email address gave an agent a clear identity instead of letting it borrow mine.
Paired technical field noteThe first useful agent teammate needed a Gmail accountA work list became trustworthy only after every place that described the work followed the same simple rules.
Paired technical field noteMy agents needed a filing system before they needed more intelligenceIf people need to debate where a note, decision, or piece of work belongs, the organization system is asking them to solve the same problem over and over.
Paired technical field noteI killed my clever vault hierarchy in one dayA stalled migration audit showed why a second compatible online address lookup can save a day of work.
Paired technical field noteMy whole 1,200-domain provider split died instantly: keep a second DoH provider on handA day of overlapping AI work showed me why every open task needs a name, a record, and a clear end.
Paired technical field note35 sessions and no mapI closed out one piece of paperwork by hand and hit seven separate annoyances doing it. Instead of just remembering to be careful next time, I wrote each one down as a rule the process now follows automatically.
Paired technical field noteWhen a Manual Workflow Hurts in Seven Small Ways, the Seven Ways Are Your SpecA content process becomes hard to trust when draft, review, approval, publication, and correction exist only as assumptions or messages.
Paired technical field noteWhen a Content Workflow Needs Explicit StateA routine data-maintenance task failed because a date was turned into display text and then treated as dependable data again.
Paired technical field noteAvoid Unnecessary Date String Round TripsA written boundary turned a desktop into a safer helper I could reach from my phone.
Paired technical field noteBootstrapping a New Agent Station, and Giving It a PhoneSome conflicts cannot be resolved from data alone because the correct result depends on what the people involved intend to do next.
Paired technical field noteWhen the System Cannot Know Intent, Make the Decision ExplicitA second review is useful when it makes assumptions and disagreements visible, not when it creates the impression that another answer automatically wins.
Paired technical field noteA Second Review Is Useful When You Record the DecisionA familiar diagnosis can encourage people to reuse a prior fix before they have checked whether the current case actually has the same shape.
Paired technical field noteSame Root Cause Is Not Same Fix: Verify the Data Shape, Not Just the SymptomLater is not a plan when no one knows what evidence will make the work necessary.
Paired technical field noteDo Not Defer on a Vibe: Use Named Decision TriggersWhen a project pauses, the next person should not have to reconstruct the last decision from old messages and half-finished notes. A useful handoff turns restarting into a lookup.
Paired technical field noteWrite the Handoff Before You Close the Session, or Pay to Rebuild State Next TimeTwo items can both look inactive while needing entirely different next actions. One may be waiting for someone. Another may be deliberately parked.
Paired technical field noteA Backlog State Should Tell You What Happens NextWhen relevant information lives in separate places, a simple work decision becomes an investigation. Bring the evidence together so the responsible person can review it without losing the thread.
Paired technical field noteI Built a Triage Cockpit Because Context Switching Was Eating the DayAs more work moves across projects, tools, and people, the hidden cost is often the same: someone has to keep restating what matters. A shared, readable record can make restarting less expensive.
Paired technical field noteThe day my notes became infrastructureSeveral reasonable fixes can make a result worse when each one responds to a local concern without anyone rereading the whole thing.
Paired technical field noteAll Seven Reviewers Passed. The Writing Was Worse. Here's What Went Wrong.A publishing check found that sensitive details can survive in the copies and labels around a clean-looking page.
Paired technical field noteWhy Publication-Time Redaction Is Not a Privacy ProgramAn output can look normal while quietly dropping an important class of information.
Paired technical field noteYour Committed Output Is a Free Golden TestWhen a workflow gap needs a tool, the safe first version often gives an operator a preview, a policy check, and an audit trail instead of a raw update.
Paired technical field noteWhen a Workflow Gap Needs an Operator Tool: Preview, Policy, and an Audit TrailA tiny setting made dozens of kinds of edits look successful even though nothing was actually saved.
Paired technical field noteA var EDIT_DATABASE = false Sat in a Branch for 2.5 Years. Then We Shipped It.Old work can carry temporary conditions that no longer belong in the current release.
Paired technical field noteBefore You Merge a Long-Idle Branch, Audit Its Temporary ScaffoldingA recommendation becomes risky when it can be mistaken for work that someone has already approved or accepted.
Paired technical field noteAI Can Only Say "Suggested": The Invariant That Keeps AI Triage From Flooding Your TeamA release can be finished safely from a computer that never held the project files, if the right checks and human decisions stay in place.
Paired technical field noteClosing a Ticket From a Machine That Never Cloned the RepoA backlog can look urgent even after the underlying issue has changed, been solved elsewhere, or needs a different kind of decision.
Paired technical field noteHow to Triage an 880-Ticket Backlog Without Deleting Real WorkA useful explanation can still be hard to act on if the decision, owner, and next step are buried in conversation instead of made visible to the people who need them.
Paired technical field noteIf Your AI Workflow Only Exists in Comments, You Have ExhaustA nearly finished checkout page still needed a person to notice one small movement that made it feel wrong.
Paired technical field noteThe last 2 pixels still need a humanA repeated correction is not always quality control. It can be a quiet signal that the process or tool is producing an unreliable result.
Paired technical field noteThe workflow broke in the glue code, not the AIAfter a rush of automated traffic, the durable fix was a simple map that showed us how to see the next problem clearly.
Paired technical field noteThe method outlasts the patchA file that appeared to vanish during a deploy was actually a warning that the machine had run out of breathing room.
Paired technical field note"Bamboo is broken" was wrong: a deploy that races the filesystem under CPU pressureAutomation can look efficient while quietly overwriting the choices people already made with care.
Paired technical field noteThe Auto-Approval Feature That Quietly Rewrote Curated DataA routine folder cleanup revealed that a weekly backup had quietly stopped long before anyone noticed.
Paired technical field noteMy backups had been dead for three weeks. I found out by accident.A repository move uncovered scheduled work that looked active but was no longer producing a recent backup.
Paired technical field noteA Migration Became the Audit I Had Never RunA routine update command nearly mixed unfinished work into an urgent repair because it did not know the difference between two kinds of work.
Paired technical field noteHotfix branches need different rules than developFor a while, payments arrived while registration records quietly said they had not.
Paired technical field noteThe bug was wearing a trench coatDifferent screens can each sound credible while describing different versions of the same product.
Paired technical field noteI had to stop letting the package tier pretend it was the productA small migration can become a larger decision when it changes how people publish, find, govern, or maintain shared work.
Paired technical field noteThe blog merge that turned into a platform decisionA slow screen is not always a performance problem first; it may be gathering information no one needs.
Paired technical field noteA 25-Second Admin Screen Meant We Trusted the Wrong QueryRepeated fixes can be a sign that the work has outgrown the way it is being presented. Before improving another detail, ask whether the process still fits the task people need to complete.
Paired technical field noteThe Create-Event Dialog Had to DieAn afternoon of AI use showed me why a good rule is not enough when the work gets messy.
Paired technical field noteThe token-killing proxy I tested instead of trusting my own disciplineA useful experiment can become hard to trust when it quietly reaches shared work that was never part of the original question.
Paired technical field noteThe Real Fix Was Starting Over With a Smaller Blast RadiusA successful-looking screen can hide different rules behind what appears to be one action.
Paired technical field noteThe Bug Was Not in the Mobile UIA plausible patch can repeat a problem when the underlying state was never examined.
Paired technical field noteThe Fastest Legacy Hotfix Is Often a DiagnosticAn AI-assisted design can look finished while missing the exact details that make it work for real people.
Paired technical field noteAI Will Happily Produce the Wrong MockupA schedule went out of order because a date number quietly became text, and text follows a different kind of order.
Paired technical field noteWhy schedules broke around March 4, 1973: a getTime() digit-count sort bugA pricing label hid three separate purchases, so I had to separate everyday access from a one-weekend event.
Paired technical field noteThe Bundle-Ceiling Model: Separating Subscription and Per-Event CostA small documentation example had to be rewritten because four punctuation marks could change how an older web page read the file.
Paired technical field noteClassic ASP Doesn't Care That It's a Comment: The Script-Delimiter CollisionA late-night redesign showed why a new screen is not ready until the money underneath it still adds up.
Paired technical field noteA `?prototype=1` Flag and 23 Commits: Prototyping a Redesign in Production CodeA small label already in the site menu solved most of a tier question, until one page appeared after the label had been applied.
Paired technical field noteI Almost Built an Entitlement System for a Feature That Was Already a PageA pricing idea becomes real only when the conditions that allow, limit, and verify it are explicit enough for people to review.
Paired technical field noteThe Pricing Rewrite Only Got Real When I Wrote the GatesA protective rule can harm legitimate users when a signal that looks suspicious actually reflects a normal route, redirect, or work pattern.
Paired technical field noteThe rate-limiter that banned our power users: 302 to 200 redirects look like an attackAI context that lives only in one folder or one person’s setup disappears when work moves to another clone, tool, or teammate.
Paired technical field noteMy AI Agent's Memory Was Per-Folder, So My Clones Never Learned From Each OtherA control panel kept blocking a real administrator because its safety check counted its own detours as suspicious clicks.
Paired technical field noteThe attacker was our own redirect logicA successful deployment can prove that a process ran, not that the intended change reached the live place people actually use.
Paired technical field noteDon't Trust the Green Deploy: Grep the Live File for Your Ticket MarkerA blank space on phone screens came from moving one piece of a page and leaving the rest behind.
Paired technical field noteThe Banner Wasn't a Safari Bug, It Was an Empty FrameA familiar dashboard can consume attention and time without helping anyone make a better decision.
Paired technical field noteThe Page Was Performing a Ceremony, Not a JobA small setup habit kept a task from running unless I stayed close enough to rescue it.
Paired technical field noteThe Agent Owns the Browser, or You DoA visible nuisance can distract from a deeper path that changes or removes work.
Paired technical field noteThe CSS Bug That Was Actually a Delete BugReference material fails when people can find it only after they already know the answer.
Paired technical field noteI Had to Turn My Internal Docs into a ProductA file of instructions can change repeatable work as materially as a source file.
Paired technical field noteYour AI Skill File Is Part of Production NowA request for a new path can hide a usable path that already exists but is hard to find, explain, or trust.
Paired technical field noteThe new door was already in the buildingMoving someone to a new place does not explain what they found or what to do next.
Paired technical field noteThe Migration Ticket Was Hiding a Landing PageSeveral ordinary fixes can become expensive when each must travel through many release paths.
Paired technical field note187 Commits to Fix Four BugsA release marker can be accurate and still leave the real work unfinished. People need to know what happens after the code is labeled ready.
Paired technical field noteThe Real Release Started After the TagA small cleanup becomes risky when long-lived workspaces each carry their own history.
Paired technical field noteEnv drift was the real bugA simple defect can take far longer to resolve when the surrounding traffic, safeguards, and checks do not tell the same story.
Paired technical field noteThe SSL bug was easy. The bot traffic made it a day-long incident.A feature may work for experienced users while failing for people arriving without inherited setup.
Paired technical field noteThe feature was fine. First-time state was the real bug.A small choice in a page address made a useful view easy to lose until the links learned to carry it forward.
Paired technical field noteCarry Your State in the URL, Then Actually Carry It: The Dropped Query ParamAn edited file can look convincing while the real behavior is unchanged.
Paired technical field noteThe most valuable line in an agent's ruleset: verify the fix in the browser before claiming it's fixedA new request often exposes rules that were always present but never tested together in the old workflow.
Paired technical field noteA New Feature Is the Best Fuzz-Tester for Your Existing Data ModelA system can save time by choosing automatically, but a wrong choice can make every later step more expensive or confusing.
Paired technical field noteRouting Logic That Does Work on the Way In: Redirect, Auto-Select, or PromptA small new choice exposed an old assumption, sending tournament work to the wrong account until each step named its destination.
Paired technical field noteA 47,490-line JavaScript file and what it tells you about a profitable legacy appA convenient default can quietly make a choice for people long after the situation has changed.
Paired technical field noteGetAccountFilter and the Case for an Explicit Context You Can OverrideA familiar label on a web page pointed to the parent account after a new drill-down feature made the selected event different.
Paired technical field noteHand-rolled hydration: passing server state to the browser with no frameworkA trial account could not delete an empty site because a simple rule was using the wrong number.
Paired technical field noteA Client Tree-Walk That Was Really a Server Business RuleA tournament feature failed in three different ways because four parts of the system were each deciding its identity for themselves.
Paired technical field noteThe Duplicated-Derivation Bug: One Fragile Expression in Four QueriesA crowded list became easier to use when four gray labels were replaced by one sentence about what needed attention.
Paired technical field noteTrading Badge Soup for One Human SentenceA crowded item page became easier to use when its first screen answered the one question people came to ask.
Paired technical field noteAn Evening of Progressive Disclosure: Four Commits to Hide Everything Behind 'Details'A scoring rewrite made room for importance and current activity instead of treating a close text match as the whole answer.
Paired technical field noteReworking a vector-retrieval scoring formula: stop letting raw similarity be 100% of the baseRepeated explanations are a sign that important context is trapped in memory instead of being available where the work begins.
Paired technical field noteWriting an AI_CONTEXT.md So Your Assistant Stops Rediscovering Your CodebaseFive new reports only became useful after their definitions, bad data, and proof were handled honestly.
Paired technical field noteShipping a Whole Analytics Suite Into a Legacy ASP AdminA useful automation can become unavailable, uncertain, or inappropriate without warning.
Paired technical field noteMOCK_INFERENCE=1: ship every LLM feature with an env-var kill switch on day oneWhen a tool must still analyze a submission, a fast confirmation can create a false promise.
Paired technical field noteAI Mutations Aren't Optimistic-UI Candidates: Make the 'Analyzing' State HonestA working editing box can still be a bad experience when it gives people no sign that it exists.
Paired technical field noteA Tiptap Editor That's Invisible Until You Add ProseMirror's Base CSSA small project rule stopped coding assistants from repeatedly making changes that vanished at the next rebuild.
Paired technical field noteTeaching the AI to Find the Real Source File: .cursor/rules as a Compiled-Asset MapA checkout price changed after a coupon, but the payment estimate beside it kept telling customers the old story.
Paired technical field notePayPal Pay-Later Messages Won't Re-Render, So Destroy the Node and Recreate ItA flattering total can be wrong when the same work appears in several places.
Paired technical field noteSame SHAs in Two Repos: Why Commit-Count Metrics Lie in a Clone WorkflowA simple request for something new to appear first can accidentally erase the order people already created through earlier decisions.
Paired technical field note'Newest First' Is a Re-Priority Problem, Not an ORDER BYSix small production releases showed why a change should be easy to undo before it is easy to send out.
Paired technical field noteSix Production Releases in One Day: Anatomy of a Hotfix TrainA writing toolbar opened itself on page load because a software signal meant less than its friendly name suggested.
Paired technical field noteTiptap v3 Fires onFocus During Init, So Subscribe to the DOM InsteadA browser change quietly stopped a copy button from working for some people, and the safest fix was smaller than a full software update.
Paired technical field noteclipboard.js Named Its Global 'Clipboard'. So Did the Browser. Boom.A tiny change stopped a bad link from turning into a blank apology, and left an honest note about what still needed work.
Paired technical field noteResponse.Redirect Blew Up the Error Page. Server.Transfer Didn't.A small rebuild of two old admin pages made future changes safer without forcing a risky whole-app rewrite.
Paired technical field noteA fluent DOM builder for legacy ASP: modernize without a rewriteA short change can affect many people, while a large internal change may be safe to test away from live work.
Paired technical field noteRoute a Change by Its Blast Radius, Not Its Size or Your ScheduleA simple date in two file names let an older website deliver new page code without adding a large new system.
Paired technical field noteCache-Busting With No Build Pipeline: Date-Stamped Asset FilenamesA small mix-up between two payment numbers showed why the right label matters more than a clever fallback.
Paired technical field noteServer-Side JavaScript on Classic ASP in 2026: Prototype Pages and the DB Helper PatternA receipt problem led to a quieter discovery: a public payment page was accepting whatever data arrived at its door.
Paired technical field noteA Trusted Gateway POST Is Still a Public EndpointA payment receipt was using the payment service's number instead of the order's number, so I put up a temporary public page to see the real message and fix it.
Paired technical field noteShipping a Throwaway Relay Page to Debug a Payment Integration in ProdA 327-team recovery went safely because the first real result was a readable plan, not a live change.
Paired technical field noteRecovering a 327-Team League: Plan-Run Before You Touch ProdAfter restoring a deleted league with 327 teams, I found the recovery page still ready to make changes to a real account.
Paired technical field noteDon't leave the recovery gun loaded: scrubbing prod constants at end of dayA recovery plan was only as good as its handwritten inventory, so I built a check that showed what the list missed.
Paired technical field noteA code-first schema audit: keeping a 1,477-line ASP file in sync with a 14,536-column DBA recovery job only became practical when I stopped sending one tiny instruction at a time.
A recovery emergency showed why keeping several almost-identical fixes can make one old mistake far more dangerous.
Paired technical field noteN Drifting Copies Share One Bug: The Legacy Consolidation ThesisDXDEV documents how these systems are built, tested, and kept safe in the real world. If you want to inspect the implementation behind the practical lesson, start there.
Explore the Build Log →