Chapter 1: System Failure

The afternoon sun cast harsh shadows across Mason Hartley’s desk, glare forcing him to squint. He’d been meaning to adjust the blinds for hours. His neck ached from hunching forward. Fixing it felt beyond him.

There was laundry on the chair behind him and unopened mail on the counter in the next room, and he had stopped seeing either of them some time in the spring. The shelf above his desk held three thick books propping up a monitor that had come with a perfectly good stand, still in its box somewhere. That had happened in January. It had stopped being something to fix and become part of the landscape.

The one thing that surprised him every time he noticed it was the pothos on the windowsill, somehow still alive. Indigo had given it to him when he’d first set up the office, back when they both believed he’d build a workspace that was calm and organised. It had survived on stubbornness and occasional sympathy waterings. Unlike everything else in the apartment, it hadn’t given up yet.

The cursor blinked from three different monitors, each displaying work he should have finished hours ago. The unread count had reached double digits again, fourteen messages, each one a small weight adding to the pressure building behind his eyes, and somewhere in the background another meeting was starting without him. Again. He could hear the chime through his headphones, the sound of people joining a call he’d completely forgotten about until this moment.

This used to be easier, Mason thought, staring at the same twenty lines he’d been “optimizing” for two hours. The work wasn’t complicated. Back when it felt like solving puzzles instead of wading through mud. His brain kept jumping from one unfinished thought to the next. The familiar click-clack of his keyboard had once been a satisfying rhythm, a soundtrack to hours that disappeared without him noticing. Now it sounded like static, each keystroke followed by a deletion, progress measured in things undone.

The morning had started with what should have been a routine code review. Mason had joined the call three minutes late because he couldn’t find his headphones, and caught Dex mid-sentence, already pulling up the pull request, and had that familiar sinking feeling of being one step behind the pace everyone else seemed to manage without effort.

“Alright, Mason, walk us through the transaction handler,” Dex had said, screen-sharing Mason’s pull request. Dex’s workspace was visible in the corner of the share, clean desk, proper lighting, a single succulent plant next to a coffee mug. Everything looked intentional, organized, like someone who had their system figured out. Mason glanced at his own video thumbnail: dark circles under his eyes, the grainy image quality not quite hiding how exhausted he looked, his t-shirt rumpled because he’d slept in it and hadn’t bothered changing before the morning standup.

Mason had pulled up the code on his screen, ready to explain his approach. But as he started talking, something strange happened. He couldn’t remember why he’d structured it this way. The logic made sense, sort of, but when Dex asked about the error handling strategy, Mason drew a complete blank.

“So, uh, this catches the database errors…” Mason had started.

“Right, but what about the case where the payment gateway times out?” a junior developer named Kris had asked.

Mason had stared at his own code. There was a try-catch block. There was definitely error handling. He’d written this forty-eight hours ago, but it felt like he was looking at someone else’s work. The function names were familiar, the patterns were his, but the specific decisions, the reasoning behind the architecture, it was like trying to remember a dream after waking up.

“There’s… a timeout handler somewhere,” Mason had said, scrolling through the file, feeling heat creep up his neck.

“I don’t see it,” Kris had pointed out, not unkindly.

The rest of the code review had been excruciating. Mason had fumbled through explanations, made promises to add documentation he should have included from the start, and watched as Dex’s expression shifted from curious to concerned. The code worked, technically. But Mason couldn’t explain his own decisions because he’d written it in a fugue state of exhaustion and context-switching, never giving himself time to actually understand what he was building.

“Let’s take another pass at this,” Dex had said diplomatically. “Maybe add some comments explaining the flow, shore up the error handling. No rush.”

No rush, but everyone knew what that meant: this should have been done right the first time.

Mason ended the call and stared at the code. Six hours of work he couldn’t explain. That was the moment he realized something was fundamentally broken.

---

Now, hours later, Dex’s voice cut through the Teams call static again. “Mason, you there? We need that authentication module pushed before end of day.”

The question yanked Mason back from wherever his mind had drifted, probably nowhere productive, just that grey zone of mental fog where thoughts circled without landing. He’d been staring at the authentication code for forty minutes, cursor blinking at the end of a comment he’d started writing and abandoned. The comment read: // TODO: implement password validation logic but he couldn’t remember what he’d meant to write next, or why he’d stopped mid-thought.

“Yeah, sorry, just debugging something.” The lie came automatically, smooth and practised from months of covering up the fact that he was barely functioning. Mason wasn’t debugging anything. He was staring at the evidence that something deeper had broken. His coffee had gone cold hours ago, sitting in a ring of condensation next to two other abandoned mugs from earlier in the week.

The authentication module was supposed to be simple. Login, logout, password reset. Work he should have finished before lunch. But every time he sat down to write it, his mind drifted to the code review he’d promised Dex yesterday, the design feedback he owed Wren, the documentation he kept pushing off, the side project he’d abandoned for the third time this month.

He got four lines in before he noticed he’d typed did I pay the electric bill into a comment where the validation logic should have gone. He deleted it. Started again. Got as far as the token generation and found himself thinking about how long it had been since he’d called his mother.

Every line required pushing three other thoughts out of the way first. No wonder the simple feature had taken him two days.

“No problem,” Dex continued, his voice carrying that particular patience that senior developers develop after watching too many junior colleagues burn out. “Take your time. But hey, you sound tired. Everything okay?”

Everything was not okay. Mason had been sleeping four hours a night for weeks, mainlining caffeine and pretending one more commit would buy him room to breathe. His relationship with Indigo had devolved into a series of exhausted grunts and promises to “catch up this weekend” that never materialized because weekends had become just another time to catch up on work he couldn’t finish during regular hours. His back ached from hunching over keyboards, his eyes felt permanently dry from staring at screens, and he couldn’t remember the last time he’d felt genuinely excited about coding rather than just grinding through it.

“Yeah, just tired,” Mason managed. “Long week.”

It had been a long month. Maybe longer. Time had become this weird abstraction, measured not in hours or days but in sprints and deployments and the growing sense that he was always behind, always catching up, always promising to get his life together once this current crisis was resolved. But the crises kept coming, overlapping like merge conflicts in a poorly managed repository.

“Alright, well, don’t stay up too late with it,” Dex said. “Code will still be there tomorrow.”

But that was the problem, wasn’t it? The code would be there tomorrow, along with more code, and more meetings, and more Slack messages, and more of everything that had created this slow-motion disaster in the first place. Mason had somehow gotten trapped in a system where the work expanded to fill all available time and then some, where “urgent” had become the default priority level for everything, where he’d lost the ability to distinguish between what actually mattered and what just felt important because it was screaming the loudest.

Mason ended the call and stared at the authentication module again. The logic was simple enough: check credentials against the database, generate a JWT token, return success or failure. Clean, predictable, testable. Everything his personal life wasn’t.

His phone buzzed with a notification. Then another. Instagram, Twitter, a news alert about some tech company drama that didn’t matter but somehow felt urgent. Mason realized he’d been unconsciously reaching for distractions every time he hit a mental block in the code, training his brain to expect constant stimulation. No wonder he couldn’t focus on anything for more than a few minutes at a time.

When did it get this bad?

The question wouldn’t leave him alone. Six months ago, Mason had been excited about his work, proud of his growing skills, optimistic about his career trajectory. He’d been the developer who stayed late because he loved solving problems, not because he couldn’t manage his time. He’d been the person who actually read programming blogs for fun, who contributed to open source projects, who had ideas for side projects that might actually become something. He’d been sleeping seven hours a night, going to the gym occasionally, cooking actual meals instead of surviving on delivery apps and energy drinks.

Now he stayed late because he was drowning, and every day felt like treading water in an ocean of ever-increasing demands.

Mason’s phone buzzed with a text from Indigo: “Order dinner? Design review ran long, working late.”

Working late. Again. He typed back: “Sure. Thai?” and added it to the mental queue of things he needed to do, right behind finishing the authentication module and before responding to the Slack backlog.