Rozdział 1: Niemożliwy Termin

“Our biggest client just gave us an ultimatum.” Marcus Thompson stood at the head of the conference room table, his expression carefully neutral, the same look he wore before announcing layoffs last year. “That’s forty percent of our revenue. They want critical platform improvements in four weeks or they’re switching to a competitor.”

Nobody spoke. The emergency meeting invite had arrived at 7 AM, unusual for Marcus, who typically scheduled things weeks in advance. Sam Mitchell had arrived early, reviewing the thirty-five tickets covering the project backlog like casualties on a battlefield: session handling that caused cart abandonment, performance fixes to stop support hemorrhaging, security gaps threatening client compliance. The fluorescent lights flickered overhead, matching the burnt coffee smell that signaled another crisis mode.

Sam’s phone showed recent alerts: cascading errors across multiple services from earlier that morning. His coffee had gone cold diving through connected issues that led nowhere.

The team filtered in, sensing the urgency. Jordan took his usual seat, Ryan with his leather notebook, each settling in with unusual tension.

“How many hours on that authentication bug last week?” Ryan asked, trying to gauge what they were facing.

“Eight,” Sam admitted, rubbing his temples. “For a typo in a database query hidden in a rarely-used error handler.”

Ryan looked at the backlog displayed on his laptop. “At our current velocity, this is three months of work. Minimum.”

Marcus showed them his tablet with the client’s email. Hastily written, punctuated wrong, the kind of message someone fires off at midnight after a board meeting goes sideways. “Three things are killing their business. Session timeouts causing 35% cart abandonment during checkout. Page load performance so bad their support team is drowning. And they failed their security audit with findings they need resolved for compliance.”

“Those aren’t feature requests.” Sam studied the email again. “Those are survival issues.”

“For them and for us,” Marcus confirmed. “Forty percent of our revenue depends on solving these problems. In four weeks.”

Jordan stopped typing. Ryan’s pen hovered over his flowchart.

“Four weeks?” Sam asked.

Marcus tugged at his tie, a tell that meant worse news was coming. “Our competitor just stole three clients. They delivered exactly what this client wants. In four weeks.”

“What did they deliver?” Ryan asked.

“Exactly what our client needs: reliable checkout flows, sub-second page loads, security compliance. Basic table stakes for enterprise SaaS.” Marcus stopped clicking his pen. “They’re not doing anything revolutionary. They’re executing faster than we are.”

“Four weeks is impossible,” Sam calculated, pulling up their velocity charts. “We need twelve weeks minimum with our current resources.”

Marcus switched to his tablet. “Look at their numbers: feature delivery way up, bug rate way down.”

“They probably hired more people.” Sam crossed his arms.

Jordan looked up from his laptop. “Actually, I’ve been following their posts. They have half our headcount.”

“So they’re burning out their people,” Sam countered.

“No, they’re using AI development tools.” Jordan turned his laptop toward Sam. “That’s how they’re achieving these results with smaller teams.”

“Exactly.” Marcus tapped his tablet. “They’re all-in on AI development tools. Not just code completion, actual development assistance that helps them move faster.”

“You want us to adopt AI tools?” Sam asked, skepticism clear in his voice. “With four weeks on the clock?”

“What else can we do?” Marcus asked. “The client literally asked why we’re not using AI like our competitors.”

“We’re already betting the company on this deadline,” Ryan observed. “The question is whether we bet on our current approach that we know won’t work, or try something new.”

Sam leaned back in his chair. “Even if we wanted to, getting IT and Legal approval for new tools takes weeks.”

Marcus set down his pen. “Yeah, about that. I’ve been looking into this with IT for the past two weeks. Ever since we started losing clients. API costs are already budgeted. IT ran the numbers and it’s a fraction of what we spend on cloud infrastructure.”

“But which AI tools?” Ryan asked. “There are dozens of options.”

“Claude Code. IT finalized approval last week after evaluating multiple options.” Marcus pulled up the evaluation summary on his tablet. “Terminal-based, works where we already work, sees our actual environment.”

Jordan closed his laptop halfway. Ryan stopped writing. Sam could see them all running the same calculation he’d already done: four-week deadline, three developers, a backlog that needed twelve weeks. Without something radical, they’d miss the deadline and lose the client.

“We’re out of options, aren’t we?” Sam said finally.

“We always have a choice,” Marcus replied. “But the alternatives aren’t promising.”

Sam exhaled slowly, then nodded. “If we’re doing this, we do it right. Permission-based access, human review, blocking sensitive paths.”

Jordan nodded. Ryan made a note.

The Discovery

“Let me show you something,” Jordan said, pulling up his laptop. “We have that race condition causing random logouts. Been plaguing us for weeks.”

“The session refresh issue between services,” Sam recalled.

Jordan opened his terminal. He typed claude and hit enter. A prompt input field appeared immediately, then a permission request for project access.

“Every new directory gets this,” Jordan said. “Least privilege, explicit only.”

“Good. No silent access.” Sam leaned forward. “And what leaves our network? Every line of code going to their servers?”

“API calls,” Jordan said. “Nothing sticks between sessions. They don’t train on our code.” He pulled up the security documentation to back it up.

Sam made a note. He’d verify the details with IT himself, but at least the architecture wasn’t a non-starter. The security story was better than he’d assumed.

Jordan started typing a prompt: explore our authentication module, all the connection points, find whatever’s causing these random logouts between services. He added the paths for auth/ and services/session/ to scope the context. Hit enter.

Claude Code churned through the authentication module, file by file, tracing connections. The thinking indicator pulsed as it mapped dependencies. A minute later, results started populating. Session refresh logic. Two services fighting over the same token, each invalidating the other’s refresh. Right there, the exact race condition they’d been chasing for three weeks.

Sam read the analysis. It had traced the bug through four files across two services, though its first suggestion for the fix assumed a single shared database, not their federated setup. Jordan corrected the context, and the revised analysis nailed it. The kind of cross-service detective work that took a developer half a day with grep and sticky notes.

“Okay,” Sam said slowly. “That’s useful. After correction.”

“That’s the point,” Jordan said. “Fast draft, human review. Every time.”

Jordan typed a prompt about handling file access restrictions, blocking environment files and credentials.

The response appeared quickly, recommending a .claudeignore file with patterns for blocking environment files.

Sam scrolled through the patterns. “Makes sense.”

“Hold on,” Jordan said. “Let me verify that’s actually the best approach.” He typed another prompt asking Claude Code to verify against the official documentation.

The screen showed activity: web search, then documentation fetch. After a moment, a more complete response appeared. While .claudeignore existed, the more reliable approach was .claude/settings.json with a permissions.deny setting, giving finer-grained control over what Claude Code could access.

Sam moved closer. “It refined itself.”

“First answer worked but there’s a better way,” Jordan said. “From memory, it reached for an older pattern. When I asked it to check the docs, it actually went and looked. Found the recommended approach.”

Sam studied the corrected response. “How do I know it checked the real docs and not some random blog post?”

“Fair point.” Jordan pulled up the prompt again and added the actual documentation URL directly into the prompt. “When you give it the specific URL, it fetches that page. No ambiguity about the source.”

The response came back citing the exact documentation section.

“That’s the difference between ‘go check the docs’ and ‘here are the docs,’” Sam observed.

Ryan scribbled a note. “So verify against official docs, use the actual URL when it matters. Got it.”

“It also flagged known bugs,” Jordan added. “Cases where file restrictions were bypassed. Wouldn’t have caught that from the first answer.”

“This configuration gets committed to our repo,” Jordan said, creating the file. “The whole team inherits these security boundaries automatically.”

Sam watched the security configuration take effect. Thorough, at least. More thorough than he’d expected.

“One more thing before I hand this over.” Jordan typed /init in the terminal.

Claude Code started analyzing their project structure. A file called CLAUDE.md appeared: project structure, tech stack, testing patterns, architecture notes. All generated from what it found in the codebase.

“What’s it doing?” Sam asked.

“Project memory,” Jordan said. “It reads this file every session. Patterns, gotchas, anything that affects how we write code.”

“Where does it live?” Ryan asked.

“Repo root, committed to git.” Jordan pointed to the generated file. “Whole team shares it. When we hit a constraint, like stored procedures we can’t modify, we add it here so nobody rediscovers it the hard way.”

Sam read through the generated content, nodding slowly. “Operational memory. Unwritten rules made written.” He looked at Jordan. “Keep it lean though. Facts, not novels.”

“Exactly. Claude Code reads it every session, so bloat slows everything down.”

Sam Tests It Himself

Sam moved to his keyboard. “Appreciate the tour. Now I want to try this myself. Without the commentary.”

Jordan raised his hands and backed away from the screen. “All yours.”

Worth testing himself. No audience, no pressure to be impressed or unimpressed.

He started typing: “Analyze our inventory search performance issues. Study query patterns, index usage, caching strategies.” He paused. What else? Right, the scope. “Search is degrading as we scale to 100K+ items. Research the bottlenecks, don’t suggest fixes yet. If anything about our setup is unclear, ask before analyzing.”

Enter.

Asking it to understand first, not jump to solutions. And telling it to check its assumptions before charging ahead.

A question appeared in the terminal: what index configuration was the catalog currently running? Sam typed the answer. Fair question, actually. Better than guessing wrong.

Claude Code churned through the queries. Took maybe thirty seconds. Then results populated: bottlenecks identified, inefficiencies called out, places where the database was doing full table scans.

Okay. Not bad.

Sam considered this. “Now plan.” He typed: “Based on your analysis, create optimization strategies for our 100K+ product catalog. Performance standards: queries under 100ms, no N+1 patterns, proper index usage. Evaluate trade-offs, recommend best approach for quick wins.”

Generic “make it faster” wouldn’t cut it. The tool needed their actual requirements.

Three strategies appeared. Indexing looked promising for quick wins, clear trade-offs laid out. Sam scanned the details. Migration script, query rewrites, rollback plans. He checked for gotchas. Write latency? Minimal. Storage bloat? Acceptable.

He ran the migration against their dev environment. Query time dropped from 2.3 seconds to 47 milliseconds.

Dramatic, yeah. But not magic. Proper indexing they should’ve had from the start.

Next ticket. Authentication timeouts. He prompted it, got back a solution that… wait. That wouldn’t work with their multi-node setup. Classic single-server assumption. The kind of answer you’d get from a developer who’d only ever worked with a single application server.

Sam added context about their distributed architecture, the load balancer configuration, session replication across nodes. Re-prompted. The revised approach actually accounted for their setup. Sticky sessions with a shared session store fallback. Better. Not perfect, but the kind of starting point that saved an hour of whiteboarding.

Ninety minutes in, Sam pushed back from his desk. One solid win, three iterations with corrections, two tickets closed. One suggestion he’d thrown out entirely, it proposed replacing their event system with a pattern that would’ve broken every downstream consumer. But the corrections mattered: roughly a third of what Claude Code suggested needed adjustment. Not wrong, exactly. More like a good developer’s first draft that hadn’t been through review yet.

He was starting to see how this worked. Give it complete context upfront, like onboarding any developer. Then verify everything against their standards. Fast execution, but it definitely needed their architectural knowledge. And human review wasn’t optional. It was the process.

The New Developer Problem

As Sam closed his laptop, Marcus’s phone buzzed with a calendar reminder. He glanced at the screen, then winced.

“One more thing I need to mention.” Marcus checked his phone, then set it down. “Kevin Park starts next week.”

Silence followed. Sam set down his coffee cup.

“We’re onboarding a new senior developer during this deadline?” Sam asked, his voice level but his expression showing the calculation happening behind his eyes.

“We recruited him for three months.” Marcus rubbed the back of his neck. “Competed against two other offers. If we delay his start date now, we risk losing him entirely.”

“Our setup guide is basically fiction now,” Ryan said, flipping through his notebook to the onboarding section. Last updated three sprints ago, before the authentication rewrite, before the cache refactor, before everything that made their current system what it was. “Half day minimum to get the environment running with those outdated docs, and that’s if you’re lucky. Then weeks understanding what you’re looking at, learning our patterns, figuring out what’s safe to touch...”

“So we have an impossible backlog AND we’re teaching someone our system from scratch,” Jordan said, not complaining, just calculating. “That’s actually interesting timing.”

“Interesting?” Sam’s skepticism was sharp.

“We’re gonna have to teach Kevin everything anyway,” Jordan said. “The auth system, the deployment pipeline, where all the bodies are buried. Why not figure out a better way to do it while we’re at it?”

“That’s one way to look at it,” Marcus replied. “The other way is that we’re adding complexity to an already impossible situation.”

“Kevin’s expecting our ‘legendary onboarding experience,’” Marcus added with audible quotation marks. “The one we promised during recruitment. The streamlined, professional, welcoming process that gets developers productive quickly.”

Sam looked at the backlog, thought about four weeks of impossible deadline, and now pictured explaining their tangled authentication system to someone who’d never seen their codebase before.

The impossible had gotten more impossible. Unless something fundamental changed about how they worked.

The Team Decision

Tuesday morning. Sam gathered the team, his laptop showing the test results. “I spent yesterday afternoon testing Claude Code. Mixed results, but instructive. Got a solid query optimization, 90% improvement. The authentication fix initially missed our distributed architecture, but corrected itself when I provided context.”

“So it doesn’t work?” Marcus asked, leaning forward.

“It’s not that simple,” Sam said, choosing his words. “It works like a fast developer who doesn’t know our system yet. With proper context and review, it’s useful. Without that context, it makes assumptions. We need safeguards.”

“What kind of safeguards?” Marcus pressed. The rest of the team watched Sam.

“Every suggestion gets reviewed. Period. We understand every line before it touches main. Test coverage doesn’t slip. Code quality metrics tracked. Daily learning sessions. And if metrics drop, we stop. Full stop.”

“Can we deliver in four weeks without AI assistance?” Sam asked bluntly.

“No chance,” Ryan replied, showing his calculations.

“Can we deliver with it?”

Jordan straightened. “If we’re disciplined about process, yes. The teams that fail are the ones who dump everything at once without review. We’ll be systematic.”

“I’ll track everything.” Ryan opened his spreadsheet. “Velocity, bugs, technical debt. If metrics drop, we stop.”

“Quick wins first,” Jordan suggested. “Tests, documentation, bug finding. Build confidence before tackling complex features.”

“Look,” Sam said bluntly, “I’m not convinced this is our silver bullet. But I ran out of reasons to say no somewhere around the third ticket it helped me close. With extreme care, it might give us an edge.”

Marcus looked at each team member. “So we try it, but with Sam’s safeguards. Code quality drops, we stop.”

“Agreed,” Sam said. “And I mean it. The moment this causes more problems than it solves, we drop it. We’re betting the company here.”

The thirty-five tickets remained unchanged. Sam’s approach to them had not.

Four weeks. Thirty-five tickets. One untested tool. And Kevin Park arriving Tuesday with expectations of a professional onboarding experience they’d have to deliver while solving impossible problems.

Not impossible anymore. Just improbable. And improbable, Sam could work with. Wednesday’s planning session would be interesting.

To be continued in Chapter 2: Planning Through Chaos...