Monday, 09:11 — Red, Green, Refactor

Stefan wrote the three words slowly so nobody could pretend they hadn’t seen them.

RED.

GREEN.

REFACTOR.

Then he put the marker down and looked at the backend team gathered around the whiteboard like he was about to announce a religion or a layoff.

The room was already warm. Early June in Berlin. The kind of heat that arrives through the windows before the building admits it needs air. Somebody had opened both sides of the floor, and the draft carried coffee, sunscreen, and stale club smoke from whoever had slept three hours and come straight to work from Kreuzberg.

Mariana was leaning against her standing desk with her arms folded and her weight on one bare leg, black Sepultura crop tank cut high enough to show the hard line of her stomach, cut-offs short enough that Daniel had avoided looking in her direction all morning. Sofia sat two chairs over with her laptop open and a notebook she never remembered to use. Anton had wandered over from the Unity side and stayed in the back with the posture of a man attending a sermon only to heckle the preacher.

“This,” Stefan said, tapping the whiteboard, “is test-driven development.”

Anton snorted.

“You’re really doing it,” he said. “You are making tests into religion.”

Stefan looked at him.

“Only if you confuse ritual with feedback.”

That got a small grin out of Mariana.

Anton crossed his arms tighter. Sleeveless black tee. Sharp cheekbones. A sneakerhead’s posture and a Russian’s patience, which meant the patience existed mostly in theory.

“Explain the difference,” he said.

Stefan uncapped the marker again.

“Religion tells you what to believe before reality answers back. TDD asks reality a question first.” He wrote beneath the words: What should the system do? “You write a failing test that describes one behavior. The test fails because the behavior doesn’t exist yet. Then you write the smallest amount of code that makes the test pass. Then you clean it up.”

He turned to Sofia.

“What breaks first when a team is drowning?”

Sofia blinked. She’d been expecting a lecture, not a question.

“Uhh. Deployments?”

“Before that.”

She looked at her keyboard as if the answer might be hiding under the keys.

“People stop knowing what’s supposed to happen?”

“Exactly.” Stefan pointed at the sentence on the board. “TDD forces the question before the implementation. Not after the incident. Not during code review. Not when Hassan is rolling something back at 23:40 because everyone else went home.”

Hassan didn’t look up from his desk, but one corner of his mouth moved. At Pixel Spree that counted as applause.

Stefan plugged his laptop into the screen. A tiny backend function appeared. Reward multiplier calculation for a weekend event. A pure function. Inputs in, result out. The kind of thing teams swear is too small to get wrong right until it costs them forty thousand angry players.

“We had a support spike two weekends ago because gold boosters stacked wrong,” he said. “Not catastrophic. Just enough to poison a Monday. So let’s start there.”

He opened a test file first.

“Wait,” Sofia said. “You haven’t written the function yet.”

“Correct.”

“So how do you know what to test?”

“Because I know what the business rule claims to be.” He looked at Mariana. “Read me the rule.”

Mariana pushed off the desk and came closer to the screen.

“Base booster times event multiplier, capped at three,” she said. “Unless the player is in a beginner segment, then event multiplier doesn’t stack.”

“Good. That’s a behavior.”

He typed the first test out loud while he wrote it. A beginner segment player with a booster during event week should still get only the booster multiplier. Not both. The test failed, bright red on the screen, because the function didn’t exist.

“Red,” Stefan said.

He created the function. Wrote six blunt lines. No abstractions. No cleverness. The test passed.

“Green.”

Then he cleaned up two duplicated variables, renamed one misleading method, and pulled the conditional into a clearer shape.

“Refactor.”

The team watched the cycle happen in less than four minutes.

Mariana didn’t move. Sofia frowned at the screen, not because she disagreed, but because something in her brain was reordering itself and resenting the effort. Anton kept his arms folded.

“That’s easy because it’s pure,” Anton said. “Try that shit in Unity. Animation timing. Input buffering. Netcode race conditions. Not everything is a nice little function from a blog post.”

“True,” Stefan said. “Not everything is a unit test candidate. But a shocking amount of your code isn’t animation timing or game feel. It’s state transitions. Pricing logic. Inventory rules. Serialization. Matchmaking decisions. Cooldowns. Reward curves. All the deterministic stuff you currently discover is broken by shipping it.”

Anton didn’t answer.

Because that landed.

Everyone on the floor knew Anton’s pain wasn’t that games were hard. It was that too much of the Unity codebase made simple things feel mystical because nobody could separate deterministic logic from engine glue anymore.

Daniel appeared at the glass wall with his Moleskine already open.

“How much time does this add?” he asked.

The question came out sharper than he intended. He was still wearing the QA uniform he’d apparently been born in: navy polo, chinos, clean sneakers, glasses, notebook, the posture of a man who’d been told his seriousness should count as a contribution even when it slowed everyone else down.

Mariana answered before Stefan could.

“Less than production incidents,” she said.

That got a few low laughs.

Daniel didn’t laugh.

“I’m asking seriously.”

“So am I,” Mariana said.

Stefan stepped in before it turned into one of those sterile arguments where everyone protects their turf and nobody protects the software.

“It adds minutes now to remove hours later,” he said. “The same way small pull requests add overhead that eliminates merge hell. You’re moving the thinking earlier.”

Daniel’s pen moved once across the page.

“Show me by Friday,” he said.

“That’s the plan,” Stefan said.

He looked back at the backend team.

“This week you don’t need conversion. You need one honest attempt. Pick a small behavior. Write the test first. Let it fail. Then make it pass. Nobody’s getting graded on elegance.”

Mariana had already turned toward her desk.

“I know which bug I’m doing,” she said.

“Of course you do,” Anton muttered.

She looked over her shoulder at him, eyes bright, smile dangerous.

“You can keep calling it theology from the cheap seats, querido. I’m still going to try it.”

Anton barked a laugh despite himself.

That was the first crack in the room. Not belief. But movement.

Monday, 14:43 — Mariana Goes First Again

The first time Mariana swore, it was at the test.

Not at the code.

At the test.

“This looks backwards as fuck,” she said.

It was after lunch, heat pressing against the windows hard enough that the AC had given up and the whole backend corner had started dressing like the office might at any moment slide into a lake. Mariana had switched from the Sepultura crop tank to a faded Motörhead shirt she’d apparently had in her bag, knotted higher under her ribs. Iced coffee on the desk. Bare feet planted wide. Hair up because the heat was winning.

On her screen sat a tiny bug she’d wanted to kill for three weeks.

The daily reward streak reset was forgiving on day seven, strict on day eight, and completely insane if the player crossed midnight while the phone clock desynced and then reconnected. Support had documented it twice. Marcus had escalated it once. Nobody had touched it because the fix lived inside a chunk of backend logic everyone hated opening.

“Describe the behavior,” Stefan said.

“I did. I described it four times in Jira, two times in Slack, and once in all caps after support sent the same ticket again.”

“Not the story. The rule.”

She stared at the code. Then at the support screenshot. Then at the code again.

“If a player claims day seven late at night and comes back after midnight within the allowed grace period, the streak should continue. Not reset.”

“Good. Write that.”

“The test name?”

“The expectation.”

She typed with the kind of aggression that produces clean names by accident.

continues_streak_when_claim_happens_after_midnight_within_grace_period

“Jesus Christ,” Anton said from the next cluster over. “That is not a test name. That’s a cry for help.”

Mariana didn’t even turn.

“If you can read it, it works,” she said.

The test failed exactly how Stefan wanted it to fail. Not mysteriously. Not through a cascade of unrelated setup garbage. It failed because the system reset the streak when it shouldn’t.

Red.

Mariana went still.

There it was. The shape of the mistake isolated. No incident timeline. No support ticket archaeology. No PR comment thread from six days ago where somebody asked a half-serious question and got ignored. Just one clear statement of expected behavior and one blunt signal that the software disagreed.

“Fuck,” she said softly.

Stefan knew that tone. It wasn’t frustration. It was recognition.

“What?” he asked.

She kept looking at the test.

“I’ve been debugging after the fact for three years,” she said. “This is the first time the code has had to answer me before it gets to lie in production.”

The line was too good to interrupt.

She wrote the smallest fix she could tolerate. No cleanup yet. Just enough to pass the test. The green bar appeared.

Then she found two older conditionals wrapped around timezone normalization, cursed again, and refactored them into something a sober adult could read.

Ten minutes later she had one passing test, cleaner code, and a bug she’d been carrying around in her head like a stone was suddenly lighter.

Daniel appeared at the end of the desk row without anyone noticing him arrive.

“Can I see the test?” he asked.

Mariana blinked.

“You want to read the test?”

“Yes.”

She rotated the monitor toward him.

Daniel read in silence. Once. Then again. His pen tapped lightly against the Moleskine, but he didn’t write anything yet.

“This is clearer than the Jira ticket,” he said.

Mariana stared at him as if he’d briefly started speaking Finnish.

“Well. Yeah,” she said. “Because the test has to be unambiguous or it fails.”

Daniel nodded once, almost irritated by the fact.

“And if QA had this behavior written down at this level before regression, we’d argue less about expected outcome.”

“Also yes,” Stefan said.

Daniel’s eyes moved to the implementation.

“How long did it take?”

Mariana checked the timestamps.

“Twelve minutes to first pass. Twenty-one including cleanup.”

Daniel actually wrote that down.

Across the room, Katja walked by in black shorts and a band tee knotted at the waist, glasses on, coffee in hand, taking in the scene with one quick sweep. Mariana at the desk. Daniel reading a test. Stefan not speaking. The backend cluster quieter than usual because everyone within earshot was pretending not to listen.

“Should I act surprised?” Katja asked.

“Probably not,” Stefan said.

Katja looked at the screen, read the test name, and smiled with the tired precision of someone who only smiled when a system made more sense than it did ten minutes ago.

“Good,” she said. “Keep going.”

She moved on.

Daniel stayed another full minute.

“If this becomes cargo culting, I’m going to say so,” he said.

Mariana leaned back, eyes sharp.

“If it becomes cargo culting, I’ll say it first.”

Daniel nodded and walked away.

After he left, Mariana reopened the test file and looked at it again.

“You know what’s rude?” she said.

“What?”

“That this feels good. I wanted to hate it on principle.”

Stefan laughed.

“Give it until tomorrow. Then you’ll hate it for better reasons.”

“Like what?”

“Because it exposes how much code you don’t understand yet.”

She cracked her knuckles and opened the next bug.

“Perfect,” she said. “Exactly my kind of humiliation.”

Tuesday, 12:26 — Theology, According to Anton

By Tuesday lunch, the word had spread past the backend team.

Not because anyone had made an announcement.

Because Mariana had called TDD “the first useful cult I’ve ever joined” in Slack, and the message had received nineteen reactions in eleven minutes.

Anton was waiting for Stefan on the roof terrace with an iced Club-Mate and the expression of a man who’d decided he was going to be correct even if the facts made it inconvenient.

The terrace was brutal in the noon sun. Berlin in June, bright enough to bleach the edges off every building. A couple of producers were smoking under the shade sail. Someone from art had taken their sandals off and was dangling both feet off a bench like this was a lake house, not an office roof above Görlitzer Park traffic.

Anton sat on the low wall in black shorts so fitted they looked painted on, mesh sleeveless top clinging to his chest, sneaker laces glowing fresh and white. His clothes said nightclub. His face said code review.

“I watched Mariana all morning,” he said when Stefan walked over. “She’s faster because the problem is backend business logic. Clean boundaries. Deterministic rules. You think this translates to game code and everybody starts praying to the red-green bar and suddenly we’re saved. That’s bullshit.”

Stefan sipped his coffee.

“You came up here to tell me I’m overselling it.”

“I’m telling you developers always do this. They discover one practice that works in one domain and turn it into a universal moral truth. Then six months later some consultant is selling TDD maturity assessments and everyone wants to die.”

That was, annoyingly, a very good objection.

Stefan respected good objections.

“You’re right about the failure mode,” he said.

Anton’s eyebrows moved. He hadn’t expected agreement that fast.

“TDD becomes religion when people stop asking what feedback they need and start defending the ritual itself,” Stefan said. “I’m not interested in ritual. I’m interested in shortening feedback loops.”

Mariana wandered over halfway through that sentence and stole Anton’s mate without asking. Tiny cut-offs. White cropped tank. Sunglasses on her head. The sun made the tattoo on her forearm look almost blue.

“He’s still monologuing?” she asked.

“He’s making a valid point,” Stefan said.

“Disgusting,” Mariana said. “We should get you checked.”

Anton took his drink back.

“I make valid points constantly. Nobody appreciates it.”

Sofia came onto the terrace last, oversized white tee thrown over shorts, laptop still under her arm like she didn’t fully trust lunch to remain non-technical.

“Am I interrupting?” she asked.

“Only a philosophical crisis,” Mariana said.

Sofia sat cross-legged on the bench.

“Good. I have one too.”

Her voice had the frayed edge of somebody who’d been losing a fight with a tiny problem for three hours and was starting to take it personally.

“Say it,” Stefan said.

“Writing the test first makes me feel stupid.” She didn’t soften it. That was one thing Gen Z did better than his generation. They skipped the theater and named the wound. “I keep trying to test the implementation because I don’t know how to think in behavior yet. Then the test is garbage. Then I hate myself.”

Anton looked at her, then away, suddenly less interested in performance.

Because there it was. The cost. Not ideology. Cognitive retooling.

Stefan pulled a chair over and sat down so he wasn’t looming.

“What are you working on?”

“Promo code cooldown. Support wants a one-hour lockout after three failed attempts. I keep writing setup for ten minutes and ending up with a test that proves nothing.” She rubbed at one eye. “It feels like everybody else got the joke and I missed it.”

Mariana’s tone changed instantly.

“No, babe. That’s normal.” She nodded toward Stefan. “Yesterday I wanted to throw my monitor out the window for twenty minutes. Then it clicked. Sort of.”

Anton looked at Sofia over the rim of his bottle.

“You’re trying to build the whole world before asking one question,” he said. “Stop doing that.”

Sofia stared at him.

“Is that supposed to be supportive?”

“For Anton, yes,” Mariana said.

Stefan leaned forward.

“What’s the smallest question that matters?”

Sofia thought.

The city hummed below them. S-Bahn in the distance. Somebody laughing too loudly on the neighboring roof. Cigarette smoke cutting through sunscreen.

“After three failed promo attempts in one hour,” she said slowly, “the fourth attempt should be rejected even if the code is correct.”

“Good,” Stefan said. “That’s your test. No database. No API. No request object. Just the rule.”

“And if the code is correct after the lockout expires?” Sofia asked.

“That’s the next test,” Mariana said.

Anton gave a tiny nod.

“Two questions. Not twelve.”

Sofia exhaled. Not relief yet. But a path.

She stood up.

“If this doesn’t work, I’m blaming all of you personally.”

“That’s fair,” Stefan said.

She headed back downstairs with the laptop under her arm and a little more velocity in her step.

Anton watched her go.

“She’s smart,” he said.

“Yes,” Stefan said.

“That’s why it pisses me off when smart people are made to feel dumb by a technique.” Anton looked back at him. “Practices are supposed to serve the team. Not the other way around.”

“Agreed.”

Mariana stretched one leg out into the sun.

“Can you two stop agreeing? The sexual tension disappears when Russians and Germans get reasonable.”

Anton nearly choked on his drink.

Stefan laughed into the coffee cup.

And that was how the conversation ended: not with consensus, but with a cleaner line around the actual dispute.

TDD wasn’t sacred.

But it also wasn’t optional everywhere.

The art was in knowing which code deserved the question before the implementation.

Wednesday, 16:02 — The Click

It happened at 16:02 on Wednesday because of course it happened at 16:02.

Not after the morning standup.

Not during the lunch break.

Not after one of Stefan’s explanations, which would have been too neat and would have made him unbearable.

It happened because Sofia got angry enough to simplify.

She had spent most of Tuesday and half of Wednesday trying to write a test around the promo code lockout logic without dragging half the backend into the room with it. Every time she thought she had the boundary, another dependency appeared. User state. Timestamp parsing. API wrapper. Retry counter. Cache invalidation. The whole sick family lined up behind one tiny rule like they all expected to be fed.

By Wednesday afternoon she had dark crescents under her eyes and a spiral of discarded notes on her desk that looked like evidence in a police procedural.

Stefan crouched beside her chair, not touching the keyboard.

“Show me the test,” he said.

She did.

It was monstrous. Seventy lines of setup. Mock objects breeding in the corners. A test that technically failed for the right reason but taught nobody anything.

Stefan read it once.

“Delete it,” he said.

Sofia turned to him like he’d suggested arson.

“I spent two hours on that.”

“I know. Delete it.”

She didn’t move.

Mariana, from the neighboring standing desk, didn’t look up from her screen when she spoke.

“He’s right. Kill it. It’s dead already.”

Sofia swallowed. There are few humiliations sharper than deleting work in front of people you respect. Not because the work is bad. Because part of you knows it was bad halfway through and kept going anyway out of spite.

She selected the whole thing.

Deleted it.

The empty file stared back at her.

Something in her chest loosened and hurt at the same time.

“Okay,” Stefan said quietly. “What is the rule? One sentence.”

Sofia looked at the blank file.

“After three failed attempts inside one hour, the fourth attempt is blocked.”

“Good. What object owns that rule?”

“The promo service.”

“Too big.”

She frowned.

“The cooldown policy?”

“Better. What does the policy need to know?”

Sofia’s eyes moved slightly left, the way they always did when she was finally thinking instead of performing thought.

“Number of failures. Time window. Current attempt time.”

“That’s enough.”

She began again.

No mocks this time.

Just one small policy object and one test:

blocks_fourth_attempt_after_three_failures_within_one_hour

Red.

Then six lines of code.

Green.

Then the second test:

allows_attempt_when_previous_failures_are_outside_the_window

Red.

Two more lines.

Green.

She sat back. Said nothing. Ran the tests again. Green. Opened the implementation. Blinked at how little was there.

“That’s it?” she said.

Mariana finally turned around.

“I fucking hate when that’s the answer, but yes.”

Sofia laughed once, half incredulous, half offended.

“I spent a day and a half because I kept trying to prove the entire system worked.”

“And?” Stefan asked.

“And the actual behavior only needed three pieces of information.” She looked down at the code again. “Oh my God.”

That was the click.

Not joy. Not mastery.

Recognition.

The realization that half the pain came from dragging accidental complexity into places it didn’t belong, then resenting yourself for not being able to think through the mess cleanly.

Daniel passed by on his way back from the kitchen and stopped when he saw Sofia grinning at the screen like she’d just cheated death.

“What happened?” he asked.

Sofia turned the laptop toward him.

“It got small,” she said.

Daniel read the two tests. Then the code. Then the tests again.

“Where’s the rest of it?”

“There is no rest of it,” Sofia said. “That’s the point.”

Daniel stood there a second longer than usual.

He looked not irritated this time, but unsettled in a more productive way.

Because Sofia’s test didn’t merely verify behavior. It also described it more clearly than half the acceptance criteria QA had been handed all quarter.

“If requirements were written like this,” he said slowly, “QA could automate more of the regression pack instead of reinterpreting tickets every sprint.”

No one mocked him.

Mariana was the one who answered.

“Yes,” she said. “That’s the whole fucking point.”

Daniel adjusted his glasses.

“Not the whole point,” he said.

“No,” Stefan said. “But one of the good ones.”

Daniel nodded and moved on.

Sofia watched him go.

“Did I just teach Daniel something?”

“Don’t get cocky,” Mariana said. “He’ll relapse.”

The whole backend row laughed.

Sofia turned back to her screen. The two green tests sat there like a tiny act of revenge against every bloated story she’d ever been handed.

“This is the cleanest code I’ve written since I joined,” she said.

Stefan stood up, knees reminding him he was no longer thirty.

“Good,” he said. “Now write one more before the end of the day so it isn’t a fluke.”

That got him a glare, which was healthier than praise.

Friday, 17:18 — What the Week Proved

By Friday evening, the office felt different again.

Not transformed.

That would have been too easy.

But different in the way a room feels after somebody finally opens the right window.

Katja had pulled Stefan into the conference room at 16:50 with the same look she’d had Monday two weeks earlier when the DORA metrics first landed on her screen. Except this time it wasn’t dread. It was concentration with a trace of satisfaction she didn’t trust enough to name out loud yet.

Navigator filled the wall display.

The backend repository panel showed what a week of changed behavior looked like when translated into numbers. Pull request sizes had stayed below one hundred lines for four straight days. Review comments were shorter but more specific. Commit frequency had lost its old burst pattern and spread itself across the workday like people were actually integrating instead of hoarding. Test files had been touched in eighty-one percent of backend commits since Monday.

The Unity side looked almost unchanged.

Larger branches. Fewer tests. One comment thread from Anton that read like a small war fought entirely through inline remarks about serialization boundaries and fake abstractions.

“Uneven,” Katja said.

“As planned,” Stefan said.

She snorted.

“Nothing at this company has ever been ‘as planned.’” She zoomed in on the backend graph. “But yes. Uneven in the useful way. Mariana is all in. Sofia crossed from panic into competence on Wednesday. Hassan started adding tests around deployment config validation on his own, which I did not expect this early. Anton is still acting like we’ve asked him to join a monastery.”

Through the glass wall, Anton was indeed arguing with Mariana at her desk. Not hostile. Animated. His hands moving fast. Her grin wider with each objection. Sofia sitting nearby and watching both of them like she was learning two different dialects of the same argument.

“He’ll adopt parts of it once he can do it without calling it TDD,” Stefan said.

“Probably.” Katja leaned one hand against the table. The band tee was knotted at the waist now because Berlin in June had no patience for office decorum. Black shorts. White Chucks. Glasses slipping a little down her nose. “What’s more interesting is Daniel.”

Stefan looked past her to the QA area.

Daniel’s Moleskine was closed.

That alone was enough to register as a weather event.

He was talking to one of his testers while pointing at a screen, and from this distance Stefan couldn’t read the code, but he could read the posture. Curious, not defensive.

“He asked me this morning whether Navigator could correlate automated test additions with escaped defects over time,” Katja said.

“That’s a very Daniel question.”

“It’s also a useful one. I told him yes, if the tagging stays clean.” She paused. “Then he asked whether QA should start writing executable acceptance checks for the most expensive regressions instead of waiting for development to hand them broken tickets in three formats.”

Stefan looked back at the wall display.

“There it is,” he said.

“What?”

“The moment process people discover they don’t actually want more gates. They want better evidence.”

Katja folded her arms.

“You’re pleased with yourself.”

“A little.”

“Disgusting.”

He smiled.

On the screen, Mariana’s activity stood out in all the right ways. More commits. Smaller diffs. Tests added before behavior changes. One reverted experiment that had been rolled back in twelve minutes because the failing test told her exactly what she had misunderstood. Failure, contained early enough to be cheap. That was progress too, even if nobody put it in slide decks.

“Read Sofia’s log note,” Katja said.

She clicked into the daily log synthesis.

Sofia had written three lines Thursday night:

I thought TDD was about proving I was smart enough to think ahead. It isn’t. It’s about making the problem small enough that I stop pretending I understand more than I do.

Stefan read it twice.

“That’s the whole curriculum,” he said.

Katja’s mouth curved. Not a smile exactly. Approval with better bone structure.

“Mariana’s is filthier,” she said.

She opened the next note.

Tests aren’t religion. They’re witness statements. Code lies. Tests make it lie less.

Stefan laughed hard enough that Katja had to wait to keep talking.

“She’s not wrong,” he said.

“No. She rarely is when she’s angry enough.” Katja glanced at the backend floor again. “And Anton?”

She opened his note.

It was one sentence.

I still hate the sermon, but I hate invisible requirements more.

That nearly did Stefan in.

Katja let the silence sit after that. Not sentimental. Just observant.

Outside the conference room, Friday was unwinding the way healthy offices do. Not by collapsing. By tapering. Chairs rolling back. Music low. Bags appearing. Hassan already gone at 17:03. Second Thursday in two weeks he’d left on time, and now a Friday to match. Nobody panicking. Nobody hovering over the pipeline waiting for a surprise knife.

“You know what changed first?” Katja said.

“Tell me.”

“Not the metrics. The posture.” She nodded toward the floor. “People look less hunted. Mariana isn’t bracing before every merge. Sofia isn’t apologizing before she asks questions. Daniel is still Daniel, but now he’s curious. Even Anton is fighting with us from inside the conversation instead of outside it.”

Stefan watched the room through the glass.

She was right.

The change wasn’t dramatic enough for executives. Not yet. No giant before-and-after. No hero shot. Just the almost invisible shift from anticipatory dread to situational attention. Teams that stop expecting the software to ambush them think differently. They even stand differently.

“What’s next?” Katja asked.

That was the real question. Not whether this week had worked. Whether the next crisis would let it keep working.

Stefan looked at the live ops calendar pinned beside the screen. A summer event launch next week. Bigger concurrency spike than usual. More expensive rewards. Same infrastructure gaps Daniel had been nagging about for months. No proper staging mirror. Load testing still theoretical.

“Next,” he said, “reality checks whether the learning happened in time.”

Katja followed his gaze to the calendar.

Her face changed.

Not fear exactly.

Recognition.

“The event,” she said.

“Yes.”

They stood in silence for a moment, both of them looking at the same problem from different altitudes.

Then Katja closed the laptop.

“Fine,” she said. “At least now when it breaks, we’ll know more quickly why.”

“There speaks the soul of a CTO.”

“Fuck off,” she said, already opening the door.

He followed her back onto the floor.

Mariana looked up immediately.

“Do we get a verdict?” she asked.

Katja grabbed her bag from the back of the chair.

“Yes,” she said. “You’re all slightly less chaotic than Monday. Don’t get sentimental about it.”

Sofia laughed.

Anton lifted one hand in a mock blessing.

“Go in peace, my children of the failing test.”

“You’re still an asshole,” Mariana said.

“Consistent character design,” Anton said.

Daniel, from across the floor, actually smiled.

Small. Brief. Real.

That might have been the strangest thing anyone saw all week.

Navigator — Katja Müller — 5 June 2026, 22:11

Week one of TDD adoption. Backend only, mostly. Unity team orbiting the conversation like suspicious crows.

Stefan introduced red-green-refactor Monday morning. Anton called it religion before Stefan finished the second sentence. Fair objection, honestly. Development has enough rituals already. The useful distinction Stefan made: ritual defends itself. Feedback changes behavior. That line stuck.

Mariana adopted immediately. Not performatively. Practically. She used TDD on the daily reward streak bug that’s been haunting support for weeks and said, quote: “This is the first time the code has had to answer me before it gets to lie in production.” I should probably put that on a wall.

Sofia had the opposite week. Total frustration at first. Wrote giant tests that proved nothing because she was trying to drag the whole system into every assertion. Wednesday at 16:02 something clicked. She deleted a seventy-line monster, reduced the problem to one cooldown rule, and wrote the cleanest code I’ve seen from her. Her confidence changed in real time.

Anton remains skeptical, which is useful. He is correct that not all game code benefits from the same testing strategy. Rendering and game feel are not backend business rules. But even Anton admitted in today’s log that he hates invisible requirements more than he hates “the sermon.” That’s progress in Anton-language.

Daniel’s reaction is the most interesting. He came in asking how much time tests add. By Friday he was asking whether QA could automate acceptance checks against explicit behavioral examples instead of interpreting vague tickets after development is already done. He may be realizing that automated tests can replace part of the approval theater he built to create safety. I don’t think he likes that realization, but he isn’t running from it.

Navigator signals from this week:

• Backend pull request sizes stayed under 100 lines all week.
• Test files were touched in 81% of backend commits.
• Review comments got shorter and more specific.
• Commit activity spread across the workday instead of clustering in end-of-sprint panic.
• Unity repository unchanged so far. Skepticism visible in both code and logs.

The adoption curve is uneven. Good. Real change is uneven.

Next week is the summer live event. Bigger load than usual. Still no staging environment that mirrors production. Daniel has been right about that for months. If the event blows up, it will not be because TDD failed. It will be because we are still learning one practice while carrying old infrastructure debt into a new traffic spike.

But the team is thinking earlier now. Smaller. Clearer. That’s not enough to save us from everything. It might be enough to show us exactly where the next fracture is.

This is a work of fiction. Names, characters, businesses, events, and incidents are products of the author's imagination. Any resemblance to actual persons, living or dead, or actual events is purely coincidental. Caimito Navigator is a real product referenced in this fictional narrative.