Ok, today I will stir up a hornet's nest (I hope...).
More and more often, I see companies building Qt applications blindly defaulting to QML, without considering whether it actually makes sense for the project at hand.
Hear me out: I'm not saying QML is bad. It's great. It's great in a few scenarios:
Teams with dedicated UI/UX designers crafting the interface while developers handle the backend;
UIs requiring multi-touch interaction or fluid animations.
Now... all of that is also possible with Qt Widgets (yes, Qt Designer exists and can be used by UI/UX designers easily), but it's just easier to do in QML.
But what if you are developing a native desktop application and your team consists of C++ developers? Still defaulting to QML? What for?...
I needed a rather complex widget with several custom interactive elements. Because of its complexity, instead of hacking away inside the main application, I decided to build a standalone test app for it.
That felt like the perfect opportunity for an experiment: I implemented it twice — one app with Qt Widgets and one with QML. Both looking and behaving in the exact same way.
Coding process? I'll leave that out, as it's subjective — I've been writing C++ for over 30 years, so for me the Widgets version was easier, though someone else might have a different perspective.
Under the hood, however, the technical differences between the two are substantial:
On disk: The Widgets version is 94 MB; the QML version is 144 MB. The number of dependent files and libraries for QML is massive.
When running:
RAM usage is twice as high for QML, with 4x more virtual memory reserved.
QML spawns more threads, and the main thread is constantly working, even when the app is completely idle.
Everyone focuses on the fight between declarative languages vs. multi-paradigm C++, which is completely subjective, so I won't get into that - but I can't remember anyone talking about the cost.
Now, to me, developing an application in general - and for mobile devices in particular - is about making it as small and performant as possible. I know, good old engineering seems to be a thing of the past, and today people are vibe coding terrible pseudo-applications, but... come on!
Don't get me wrong: as I said at the beginning, QML is a fantastic technology when applied to the right problem. If you have dedicated UI/UX designers building touch-first interfaces, fluid canvas animations, or modern automotive dashboards, QML shines.
The problem is when QML becomes the blind default.
Before picking it for your next project, ask yourself: what are you actually buying in exchange for the overhead?
Do you really need an entire JavaScript runtime and a scene graph running just to display forms, tables, dialogs, and toolbars?
Is your desktop app actually benefiting from that extra space on disk, bigger RAM footprint, and background thread churn?
If your entire team is composed of seasoned C++ engineers, why force them into JavaScript/QML bindings and runtime debugging just to build standard desktop UI?
Qt Widgets is mature, rock-solid, incredibly fast, and respects the user's hardware. It is not "legacy" or "deprecated" — it is simply a specialized, hyper-efficient tool.
Use QML when its strengths directly solve your UI requirements. But if you're building a classic desktop tool with a C++ team: stop defaulting to QML just because it feels newer. Make it a conscious, reasoned architectural decision.
I have just released a brand new version of my VideoEditor app.
From user's point of view, there're two main things:
A new feature: cropping the image
Stability and performance fixes
There're also other changes, too - but those are more technical, like new Qt version (6.12 LTS), new FFmpeg libraries (9.0.2), new tests, some refactorings etc. If anyone's interested, it can be checked on GitHub.
I've also recorded a short video, explaining how to use the app. As of now, this video is only in Polish.
Over the past few weeks, we examined how generative AI is quietly restructuring the software engineering team.
In The Junior Developer Extinction Event, we explored what happens when early-career engineers rely on AI assistants for starter tasks, bypassing the manual friction that builds diagnostic intuition and mental models. In Beyond Ticket Velocity, we analyzed why a senior engineer's real contribution cannot be measured in raw ticket throughput, but in architectural prevention, perimeter defense, and unblocking team flow.
This time, let's have a closer look at Quality Assurance.
When developers use AI assistants to generate code faster, they also produce large volumes of unverified logic. As discussed in The AI Review Paradox, syntax generation is now cheap, making verification the primary operational bottleneck.
That leaves open the role of engineers responsible for verifying that the system actually works.
Some engineering leaders conclude that because AI generates unit tests in seconds, dedicated QA is obsolete. That conclusion misunderstands what testing accomplishes.
A developer needs to implement a subscription upgrade endpoint that recalculates prorated billing, updates customer tier limits, and fires webhooks to downstream analytics services. Using an AI assistant, they generate the implementation in twenty minutes.
To satisfy the repository's CI pipeline requirements, they prompt the model: "Write comprehensive unit tests for this function."
Thirty seconds later, a clean test file appears:
describe("SubscriptionService - UpgradeTier",()=>{it("should prorate billing and update tier limits correctly",async()=>{constmockRepo={updateTier:vi.fn().mockResolvedValue(true)};constmockBilling={calculateProration:vi.fn().mockReturnValue(42.50)};constmockEvents={emit:vi.fn()};constservice=newSubscriptionService(mockRepo,mockBilling,mockEvents);constresult=awaitservice.upgradeTier("cust_123","enterprise");expect(result.success).toBe(true);expect(result.chargedAmount).toBe(42.50);expect(mockRepo.updateTier).toHaveBeenCalledWith("cust_123","enterprise");expect(mockEvents.emit).toHaveBeenCalledWith("tier.upgraded",expect.anything());});});
The CI runner executes the suite. Every test passes on the first run. Code coverage reports 94%. The pull request receives green checkmarks and merges before lunch.
Three days later, an enterprise customer upgrades their subscription during a concurrent checkout, and the system double-charges their credit card while leaving the tier limits at the free tier. The database transaction rolled back halfway through, but the webhook still fired, triggering external billing retries that corrupted the ledger.
The test passed because it was authored by the same pattern-matcher that wrote the code. It validated only that the implementation agreed with itself, ignoring database transaction boundaries and concurrent race conditions.
The Tautological Test Trap
Generating unit tests against unverified code produces tautological tests: suites verifying implementation choices rather than domain requirements. It is the software equivalent of a student grading their own exam with an answer key they hallucinated.
AI-assisted development is dangerous because models generate plausible code paired with equally plausible tests.
When a human writes code and tests, their blind spots can carry over into the suite. When an AI writes both, those blind spots amplify systematically:
Mock-to-Mock Mirrors: AI-generated unit tests lean heavily on mocks, asserting that Mock A calls Mock B with Argument C. The test passes immediately, but validates only artificial wiring. It tells you nothing about how the database engine, external API, or network driver behaves under real conditions.
Bug Affirmation: If an AI assistant introduces an off-by-one error or mishandles an empty collection in the business logic, asking that same AI to write tests produces assertions that validate the bug as expected behavior. The test enshrines the defect as an invariant.
Happy-Path Sycophancy: Large language models complete patterns toward expected success. Unless specifically instructed, an AI rarely generates hostile edge cases: socket timeouts halfway through a write, dirty reads under READ COMMITTED isolation, or payload keys containing unexpected Unicode null bytes.
graph TD
classDef aiLoop fill:#ffebee,stroke:#c62828,stroke-width:2px;
classDef trueLoop fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px;
classDef step fill:#f5f5f5,stroke:#333,stroke-width:1px;
subgraph "The Tautological AI Loop (False Security)"
A1["AI Generates Feature Code"]:::aiLoop --> B1["Prompt: 'Generate Unit Tests'"]:::step
B1 --> C1["Tests Mirror Code Assumptions & Mocks"]:::step
C1 --> D1["CI: 95% Green Coverage"]:::step
D1 --> E1["Production Incident Under Real Invariants"]:::aiLoop
end
subgraph "Independent Quality Architecture (Resilient Delivery)"
A2["Spec & Invariants Defined (Three Amigos)"]:::trueLoop --> B2["Implementation (Human + AI)"]:::step
A2 --> C2["Adversarial Tests & Mutation Suite (QA + Dev)"]:::step
B2 --> D2["Hostile Verification & Exploratory Probing"]:::step
C2 --> D2
D2 --> E2["Hardened Production System"]:::trueLoop
end
When 90% test coverage takes twenty seconds to generate, coverage ceases to be a proxy for software health. A green build becomes an illusion.
For years, industry consensus treated manual testing as an obsolete relic and automation as the only true engineering discipline. Teams tried to automate every test case, pushing manual testing into low-status administrative work.
Both sides of the old debate relied on mechanical labor:
Scripted manual testing (running an 80-step spreadsheet checklist) was always low-signal. Today, multi-modal AI agents and headless browser drivers execute scripted checklists without human supervision.
Rote test automation (writing boilerplate Playwright or Cypress scripts for form inputs) was treated as high-value engineering. AI assistants now generate those browser automation scripts from a single screenshot or DOM snapshot.
Automating mechanical clicking and script generation shifts high-value engineering elsewhere.
Exploratory testing is structured, hypothesis-driven probing.
Experienced QA engineers develop theories about where system assumptions clash:
"What happens if a user opens two browser tabs and submits two different discount codes on the same checkout session within 50 milliseconds?"
"What happens if a user changes their organization slug while an external webhook delivery is in-flight?"
"Does this error message guide the user to recover, or does it leave them in a cognitive dead-end where they resubmit and corrupt their state?"
These scenarios demand domain empathy, user psychology, and an adversarial mindset. AI models struggle here because they lack a mental model of human confusion, opportunism, or error.
The traditional handoff model (writing code, pushing a card to "Ready for QA", and throwing it over the wall) was already flawed. With generative AI tools, it collapses completely.
By the time an AI-assisted developer finishes a feature, they have already generated hundreds of lines of code and matching tests based on whatever assumptions they fed the model. If those assumptions were flawed, the entire foundation is rotten.
Modern QA prevents bugs before code is prompted by driving Spec-Driven Development and Three Amigos sessions (Product, Dev, QA):
Interrogating Edge Conditions Upstream:"What is the fallback state if the payment provider returns an HTTP 504 during the capture call?"
Defining System Invariants: Specifying non-negotiable rules (e.g., "A customer balance can never be negative", "A tenant can never view a record whose organization ID does not match their JWT claim").
Preventing Requirement Ambiguity: When acceptance criteria are precise and formalized, developers prompt AI tools with strict boundary conditions rather than open-ended guesses.
The Upstream Multiplier
Finding a flawed invariant during a 30-minute specification review costs almost nothing. Finding that same flawed invariant in production requires debugging logs, rolling back releases, issuing customer apologies, and reconciling corrupted database rows.
When code assistants can generate hundreds of unit tests in seconds, QA engineers govern the test suite to ensure tests provide diagnostic value rather than vanity coverage.
Mutation testing operates by programmatically injecting small faults ("mutants") into the codebase:
- Changing a > operator to >=.
- Swapping true with false.
- Deleting an internal function call or returning early.
Original Code: if (user.balance >= item.price)
Mutant Injected: if (user.balance > item.price)
The mutation engine then runs the test suite against the mutated code:
- If a test fails, the mutant is killed (the test suite caught the bug).
- If all tests pass, the mutant survived (the test suite is blind to that logic).
A test suite with 95% line coverage but a 30% Mutation Score Indicator (MSI) is synthetic noise. Quality engineers enforce mutation thresholds so that generated tests assert runtime invariants instead of executing dead lines.
Rather than relying on brittle unit mocks for external dependencies, QA implements contract testing (such as Pact). Contract tests verify schema agreements directly, preventing breaking changes that mocks hide.
Software developers and AI models share a common bias: they construct software to succeed. They focus on the happy path, standard data formats, and intended user workflows.
Quality engineers bring institutional paranoia, designing experiments to break the system:
State Machine Tampering: Submitting requests out of sequence (e.g., triggering an order cancellation while the capture step is processing).
Concurrency & Race Probing: Executing simultaneous writes across multiple workers to see whether database isolation levels prevent lost updates.
Data Boundary Hostility: Pushing extreme inputs: zero-width spaces, deeply nested JSON objects, maximum integer overflows, and malformed authorization headers.
User Empathy & UX Failure: Identifying where the interface confuses the user, fails to explain system errors, or encourages risky user behavior.
This investigative mindset cannot be automated because it relies on understanding what the system should not do.
Verification extends into production, where QA engineers collaborate with SREs to monitor live systems:
Synthetic Production Monitoring: Running automated probes that simulate real end-user transactions in production continuously, alerting the team before actual users encounter an outage.
Canary & Feature Flag Verification: Verifying new releases against a 2% user slice, checking error budget burns and latency percentiles before broad rollout.
Testing Probabilistic AI Systems: As products increasingly incorporate LLMs, RAG pipelines, and automated agents, QA faces non-deterministic software. Quality engineers build evaluation harnesses to measure prompt regression, evaluate hallucination rates on curated golden datasets, and track output drift over time.
Measuring "Bugs Found in Jira": Evaluating QA engineers by the number of bug tickets they log creates perverse incentives. It encourages logging trivial visual quirks and creates adversarial friction with developers, while discouraging the most valuable work: preventing bugs upstream during specification.
Mandating Raw Code Coverage Gates: Setting a hard rule like "All PRs must have 90% coverage" encourages developers to generate synthetic AI tests that verify nothing. It rewards volume over diagnostic strength.
The Isolated QA Silo: Keeping QA in a separate phase at the end of the sprint turns them into a bottleneck. Developers dump unverified code into their queue, and QA gets blamed for release delays.
Generative AI commoditizes code production. A developer with a coding assistant can produce hundreds of lines of syntax, unit tests, and documentation in minutes.
That speed is only an asset if the system remains reliable. Accelerating code generation without strengthening verification manufactures technical debt at machine speed.
Mechanical tasks, like manual checklist execution and boilerplate test scripting, are now automated. In their place stands the Quality Architect.
The advantage belongs to organizations that pair generation speed with disciplined verification architecture, ensuring test suites validate real system invariants rather than artificial mocks.
I use FFmpeg quite a lot, both as an application and as a library in my own apps.
Most of its structures have their own allocators and deleters. This can be a bit annoying to work with in C++ if you're not careful. I'm catching myself in forgetting something in my code occasionally, even if I use it a lot.
Yesterday, when working on one of my old apps (Video Editor), after finding yet another mem leak in calling FFmpeg API, I said to myself - that's enough! Let's have some RAII here.
RAII stands for Resource Acquisition Is Initialization. It's a C++ programming technique that ties the lifetime of a resource to the lifetime of an object. Sounds a bit strange, but the result is that the resource is automatically released when the object goes out of scope. This is a very powerful technique that can be used to prevent many common programming errors.
But that's not the case for most of FFmpeg structures. They are allocated usig their own allocators and deleters, so we need a custom deleter for each structure, for example:
If you're curious, my Video Editor app and its sources are available on GitHub. It has quite a long history and came through few fundamental rewrites, mostly due to Qt.
In the beginning, for displaying videos I was using just QtMultimedia widget, while for transcoding I was calling FFmpeg executable in a child process. The issue was, back then QtMultimedia was using native media player, thus not supoporting many various codecs. That was leading to funny situations, that it couldn't display a loaded video, but it could transcode it 😒
Then, I rewrote the player entirely in OpenGL and FFmpeg library, so it could play almost everything. Once this was done, I changed also the transcoding to use the libraries and not the executable, too, so it's consistent.
Then, go figure, Qt implemented FFmpeg support 😁 So I returned back to QtMultimedia widget but transcoding is still using FFmpeg library directly.
I'm releasing a new version of Video Editor every few months (sometimes every few years 😉 ) - and there's an upcoming release, which should happen this week, as I've finally polished a new functionality: cropping the frames image.
Last few months I've spent working mostly on Python and Rust projects. Yesterday I wanted to get back to one of my old projects written in C++ using CMake.
Up to yesterday I was using CMake manually, so I wanted to try an extension for Visual Code for that - really nice extension, I must say, but that's another story. You can find it here.
But, as soon when I've tried configuring my project, it struck me with an error:
[cmake]NoCMAKE_CXX_COMPILERcouldbefound.
Erm... what?? 🤨
I know last few months there were few things going on, like updating CLang for the sake of building a Whisper library for Rust, and of course some updates, but... come on!
Digging for details in CMakeConfigureLog.yaml showed this:
LINK : fatal error LNK1104: couldn't open file "ucrtd.lib"
Ok, so some issue with Windows SDK. I've checked: I have few of them installed, including the one I wanted (10.0.26100).
Started my research on how the detection works. After some time, finally found it: there're two important registry keys, storing the location of Windows Kits: HKLM\SOFTWARE\Microsoft\Windows Kits\Installed Roots and HKLM\SOFTWARE\WOW6432Node\Microsoft\Windows Kits\Installed Roots. Which one is read is chosen during configuration, basing on what is the host and what is a target. Here I need x64 target on x64 host.
In previous articles, we established a few fundamentals about measuring software teams:
Ticket velocity measures activity, not delivery. As discussed in How to Measure Devs Without the Drama, story points and ticket counts are internal estimation tools, not management currency. Using them to evaluate individuals triggers Goodhart's Law: developers adapt by inflating estimates, splitting trivial tasks, and avoiding complex problems. Real delivery is measured at the system level through flow and stability metrics like Cycle Time and Change Failure Rate.
Syntax generation was never the bottleneck. In The AI Review Paradox, we explored the growing asymmetry between generation and comprehension. An LLM can produce hundreds of lines of plausible code in seconds, but verifying that code for concurrency safety, data integrity, and architectural fit still requires careful human reasoning. Accelerating code output without scaling verification capacity only increases technical debt.
The most valuable work is often invisible. In When Underperformance Is Just Invisible Work in Disguise, we saw that unblocking teammates, resolving ambiguity upstream, and filtering organizational interruptions rarely show up as closed cards on a sprint board.
This brings us to a practical question: What role does a senior engineer actually play in a modern team?
When syntax generation is cheap and card counts are easy to game, a senior developer's value cannot be measured by personal ticket throughput. Their job is not to be a faster typist. Their real value lies in multiplying the effectiveness of the people around them, preventing bad code from being written, and keeping the system reliable.
Real engineering impact rarely looks dramatic on a burndown chart. It shows up in team-wide flow, architectural prevention, diagnostic skill, and perimeter defense.
mindmap
root((Real Engineering Impact))
1. Team Flow & Mentoring
Team-wide Cycle Time
Lower review latency
Three Amigos leadership
Oral Defense of Code
2. Preventive Architecture
Zero-code solutions
Spec-Driven Development
Lower Dev-QA bounce rates
Optimizing for deletability
3. Diagnostic Skill
Fast MTTR reduction
Durable sub-layer mastery
Deterministic repro harnesses
Root-cause eradication
4. Perimeter Defense
Shielding team from drive-by DMs
Lower Bus Factor
Taming invisible work
Shared system knowledge
A junior developer focuses on their own output. A senior engineer treats the entire engineering team as a system whose total throughput needs improvement.
Measurable Signal: Lower team-wide Cycle Time (time from first commit to production deployment) and faster PR Review Turnaround, without increasing the defect rate.
Key Behaviors:
Prioritizing reviews over new work: Reviewing a teammate's stuck Pull Request or fixing a broken CI pipeline before pulling another card from the backlog.
Upstream alignment (Three Amigos): Running structured syncs between Product, Development, and QA before coding starts. As explored in The Waterfall-in-Sprints Trap, catching ambiguity early prevents days of downstream rework.
The Oral Defense of Code: Refusing to let developers treat AI tools as black boxes. Sitting down with engineers to ask: "Walk me through this method. Why did you choose this lock? What happens when this network call times out?" (See The Junior Developer Extinction Event).
When a senior unblocks two teammates, the whole team ships faster. On a personal velocity chart, that senior looks like they slowed down. Any metric that penalizes mentorship is broken.
The most effective engineering often involves writing less code, or deleting abstractions that should never have existed.
Measurable Signal: A sustained decline in the QA ↔ Dev Bounce Rate (the percentage of tickets rejected by QA and returned to developers), fewer deployment rollbacks, and a flat or shrinking codebase footprint.
Key Behaviors:
Spec-Driven discipline: Defining boundary conditions and contracts before writing implementation code. In The Spec as the New Source Code, we argued that when prompt generation is cheap, clear specifications are what prevent hallucinated ambiguity.
Rejecting premature abstractions: Pushing back against unnecessary micro-frameworks and generic layers. Applying the AHA principle (Avoid Hasty Abstractions) and designing code that is simple to delete rather than speculative to extend (see The Abstraction Tax).
Eliminating scope: Asking whether a proposed feature is truly needed, or if the product team can validate the idea with existing tools and an operational adjustment.
A developer who writes 1,500 lines to solve a problem gets celebrated by vanity dashboards. A senior who solves the same problem with one database constraint and deletes 400 lines of dead code looks idle in Jira.
When production fails outside business hours, velocity points offer no help. Impact in critical moments comes from diagnostic skill, the ability to reason methodically about complex systems under pressure.
Measurable Signal: Lower Mean Time to Restore (MTTR) during high-severity production incidents, accompanied by zero recurrence of the resolved failure mode.
Key Behaviors:
Durable sub-layer mastery: When an AI assistant reaches its limits, the senior developer investigates the foundational layers: TCP connection states, PostgreSQL query execution plans (EXPLAIN ANALYZE), lock wait trees, thread contention, and memory heap dumps.
Deterministic reproduction: Refusing to guess by editing random lines until tests pass. Writing isolated reproduction scripts that prove the failure mode before changing production code.
Blameless post-mortems: Converting outage findings into automated architectural guardrails, such as query linters, timeout defaults, or health checks, so the issue cannot repeat.
Measurable Signal: Lower Bus Factor and fewer emergency interruptions disrupting the team.
Key Behaviors:
The perimeter shield: Intercepting chaotic, ad-hoc Slack questions and emergency requests from external teams. Triaging this noise so teammates can stay in deep focus.
Documenting tribal knowledge: Writing runbooks and architectural decision records (ADRs). Training peers so on-call knowledge does not remain trapped with one person.
Maintenance hygiene: Updating vulnerable container images, cleaning up dead branches, fixing flaky tests that break CI runs, and keeping local development environments reliable.
None of this hygiene produces an impressive sprint card. If nobody does it, delivery across the department stalls within months.
To evaluate real impact, leaders need to shift from activity metrics that reward volume to flow and stability signals that measure system health.
Vanity Metric
Real Impact Signal
What It Actually Tells You
Story Points / Velocity
Team-Wide Cycle Time Reduction
Velocity measures how teams inflate estimates and push cards. Cycle Time measures calendar time from code commit to working production software.
Closed Jira Ticket Count
Low QA ↔ Dev Bounce Rate
Ticket counts reward haste and shallow work. Low bounce rates show edge-case rigor and clear acceptance criteria.
Lines of Code / PR Volume
Lower Change Failure Rate (CFR)
Large PRs often signal AI copy-pasting and missing abstractions. Low CFR shows that shipped code is resilient and tested.
Commit Volume / Hours Logged
Lower Bus Factor & Faster PR Unblock Time
Commit counts reward isolated work in silos. Unblock time and bus factor measure whether an engineer shares knowledge and unblocks peers.
These impact signals map directly to DORA metrics: Deployment Frequency, Lead Time for Changes (Cycle Time), Change Failure Rate (CFR), and Mean Time to Restore (MTTR). As covered in How to Measure Devs Without the Drama, DORA metrics evaluate delivery pipelines and system health rather than grading individuals on keyboard activity.
During promotion reviews, replace sprint burndown screenshots with the Impact Narrative Model.
Ask senior candidates to submit a two-page summary covering three to four concrete case studies. Each case study addresses three questions:
flowchart TD
subgraph Impact Narrative Structure
P[1. The Systemic Problem<br/>What bottleneck, bug, or risk was slowing the team down?]
I[2. The Engineering Intervention<br/>What minimal, preventive, or architectural action was taken?]
O[3. The Verifiable Outcome<br/>How did cycle time, stability, or maintenance cost improve?]
P --> I --> O
end
The Problem: The billing service had PR review gridlock. Pull Requests sat in review queues for an average of 4.2 days because the domain model was tangled, causing a 22% Change Failure Rate on releases.
The Intervention: The engineer paused new billing features to run Three Amigos sessions, introduced Spec-Driven Development guidelines with strict schema checks, removed an unnecessary abstract factory layer (The Abstraction Tax), and ran code review walkthroughs with the two junior developers on the service.
The Outcome: Billing PR review latency dropped from 4.2 days to 1.1 days. The billing Change Failure Rate dropped from 22% to under 2%. Overall team cycle time improved by 35% over the following two quarters.
Under a velocity-first model, this developer looked unproductive for two months because they closed fewer feature cards. Under the Impact Narrative Model, they are recognized for fixing the system and accelerating the entire team.
Typing syntax was slow for decades, so counting commits and tickets became a convenient proxy for engineering effort.
That proxy is obsolete. When tools can generate endless lines of plausible code on demand, anyone can close dozens of shallow tickets while quietly degrading the architecture.
Engineering leaders need to shift from counting completed tasks to evaluating system health:
Check whether software is simpler, safer, and easier to change today than it was six months ago.
Look at team-wide cycle times and deployment failure rates, not personal ticket scores.
Value the developer who stops a bad feature before it gets built over the one who rushes a thousand untested lines into production.
Code generation is now a commodity. The real value in software engineering remains what it has always been: understanding the problem, designing clean boundaries, and helping the team ship reliable software without unnecessary drama.
Before commercial airline pilots are allowed anywhere near the flight deck of a Boeing 787 or an Airbus A350, they spend hundreds of mandatory hours in unpressurized, single-engine propeller planes.
They fly without glass cockpits or automated fly-by-wire flight directors. They learn what an aerodynamic stall feels like when the airframe begins to violently shudder beneath their seat. They manually kick the rudder pedals during gusty crosswind approaches. They practice recovering from uncoordinated spins with white knuckles, sweating through their shirts.
Aviation regulations enforce this training because when an automated system disconnects in severe turbulence at 35,000 feet, you cannot afford a pilot who only knows how to program an autopilot computer. You need a human being with visceral muscle memory, spatial orientation, and an instinctual understanding of aerodynamics.
The software industry did the opposite.
Over the past three years, we handed entry-level developers full fly-by-wire autopilot on Day 1. We told them to type their intentions into a chat box, hit Tab on ghost text, and watch working features materialize.
We called it a 10x productivity revolution, but we might be triggering an industry-wide extinction event.
On Wednesday of their first week, a junior developer picks up a ticket: export customer invoices to CSV. An AI assistant generates forty lines of clean TypeScript in seconds. The PR merges before lunch; by Friday, five tickets are closed. Management celebrates the output, questioning the need for senior salaries.
The Autopilot Paradox
Generating syntax is not engineering. Skipping the struggle of starter tasks denies novices the mental models needed to build resilient systems.
Two months later, an enterprise client exports 850,000 records. The endpoint buffers the dataset in memory, exhausts the Node.js heap, and crashes, leaving dangling transaction locks that freeze the billing cluster.
The junior pastes the stack trace into the model: "JavaScript heap out of memory. Fix this." It suggests bumping --max-old-space-size. They commit the flag and redeploy. Ten minutes later, the memory crash takes down the Kubernetes node.
The model loops in circles, and the developer freezes. Having never profiled memory, handled stream backpressure, or reasoned about garbage collection, they cannot diagnose the failure. The autopilot disconnected at 30,000 feet, and they have no manual flight hours.
For three decades, software engineering relied on an unspoken, organic apprenticeship.
Junior engineers were assigned the work seniors didn't want to touch:
Fixing obscure off-by-one errors in report pagination.
Resolving intermittent null-pointer exceptions in user session middleware.
Migrating legacy database tables to new schemas.
Reading 120-line stack traces to figure out why an integration test flaked once every forty runs.
Plumbing repetitive boilerplate controllers and wiring dependency injection containers.
Seniors often dismissed these starter tasks as grunt work, but cognitively they were intellectual weightlifting.
graph TD
classDef apprentice fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px;
classDef operator fill:#ffebee,stroke:#c62828,stroke-width:2px;
classDef step fill:#f5f5f5,stroke:#333,stroke-width:1px;
subgraph "The Diagnostic Apprenticeship Loop (Traditional)"
A1["Encounter Obscure Bug / Failure"]:::apprentice --> B1["Read Stack Traces & Diagnostic Logs"]:::step
B1 --> C1["Formulate Mental Hypothesis of System State"]:::step
C1 --> D1["Step Through Debugger & Trace Invariants"]:::step
D1 --> E1["Identify Root Cause & Deep System Mechanism"]:::step
E1 --> F1["Long-Term Architectural Intuition Forged"]:::apprentice
end
subgraph "The Prompt Operator Loop (The Illusion)"
A2["Encounter Obscure Bug / Failure"]:::operator --> B2["Copy-Paste Error Message into Prompt"]:::step
B2 --> C2["LLM Generates Plausible Code Patch"]:::step
C2 --> D2{"Compiles / Passes Lint?"}:::step
D2 -- No --> B2
D2 -- Yes --> E2["Commit Without Forensic Understanding"]:::step
E2 --> F2["Latent Vulnerability & Cognitive Atrophy"]:::operator
end
When a junior spent three grueling days hunting down a two-line race condition, they did not only fix a bug. They were forced to learn:
How thread schedulers interleave execution.
How database isolation levels (Read Committed vs. Serializable) behave under concurrent mutations.
How network latency introduces non-deterministic ordering.
How to use debuggers, inspect memory dumps, and read diagnostic log streams.
The code produced at the end of the week might have been a single mutex or an updated SQL index, but the byproduct was an accurate mental model of how computers, operating systems, and networks behave.
When an AI assistant supplies the code instantly, that entire cognitive byproduct evaporates.
The developer transitions from an investigator to an operator. When something breaks, they treat the prompt like a slot machine:
Pull the lever (paste error into prompt).
Look at the output.
If it fails, pull the lever again with a slightly different wording.
If it passes the local linter, ship it and pray.
As I argued in The Spec as the New Source Code, LLMs act as ambiguity multipliers. When an engineer does not understand the underlying system invariants, the assistant will happily generate hundreds of lines of syntactically elegant code that quietly violate security boundaries or leak resources.
When the slot machine fails to produce a working jackpot after four prompts, the operator experiences total paralysis.
If this trend continues unchecked, what does our industry look like in five years? The senior engineers who built their foundations in the pre-AI era will burn out, retire, or move into management. Below them will sit an army of prompt operators who can build an entire prototype in a weekend, but cannot diagnose why a database connection pool is deadlocking under load.
Banning AI or reverting to manual boilerplate out of nostalgia is a dead end. Instead, we must reinvent the apprenticeship.
If you are an engineering manager, tech lead, or director, your onboarding and mentoring processes from 2022 are obsolete. If you evaluate junior developers based on ticket throughput or allow them to use AI without structural guardrails, you are actively cultivating technical debt and organizational fragility.
Here is the operational playbook to rebuild the apprenticeship for the AI era:
Giving a new junior developer a ticket like "Create a REST endpoint to update user preferences" is now useless for skill development and performance assessment.
An assistant will write that endpoint in twelve seconds. You learn nothing about the developer's engineering acumen, and they learn nothing about your system architecture.
Replace starter boilerplate with forensic architecture labs:
Take an anonymized commit from a real P1 production outage your team resolved last year (e.g., a memory leak, a deadlock, or a cache stampede).
Set up a reproducible local test environment.
Task the junior with investigating and proving the failure before touching any fix:
Use profiling tools (e.g., pprof, Chrome DevTools memory snapshots, or SQL execution plans) to pinpoint the exact failure mechanism.
Write an incident post-mortem explaining the failure in plain English.
Write a minimal, deterministic automated test that reproduces the bug without fixing it yet.
Only after they can prove why the system broke are they allowed to implement the solution. This builds diagnostic muscle from day one.
In The AI Review Paradox, we explored how generating code is virtually instantaneous, while comprehending and verifying code is cognitively exhausting. When juniors submit 600-line AI-assisted PRs, senior reviewers drown.
Counter this dynamic by instituting a mandatory oral defense of code during junior pull requests.
Before a PR is approved, the senior mentor conducts a 10-minute walkthrough. The mentor points to arbitrary sections of the generated code and asks probing, invariant-focused questions:
Mentor: "The AI used an in-memory Set here to deduplicate IDs.
What happens when this endpoint processes 250,000 records?"
Junior: "It might use more memory?"
Mentor: "Don't guess. Walk me through the heap allocation.
Why didn't we push this deduplication to the database layer via DISTINCT?"
Mentor: "Walk me through the failure sequence if the third-party webhook
times out after step 2. Does this transaction roll back, or do we
leave an orphaned charge in Stripe?"
Mentor: "Why did you use this generic interface wrapper instead of a simple
pure function? Does this abstraction solve a real requirement,
or is it just AI-generated scaffolding?"
The Rule of Code Ownership
If the author cannot explain why a line of code exists, what failure modes it introduces, and what architectural invariant it protects, reject the PR immediately. Passing unit tests do not excuse architectural ignorance.
Pair programming in the AI era should focus on diagnostic reflexes rather than watching an assistant autocomplete code.
Mentors should practice deliberate fault injection:
During a pairing session, the senior quietly introduces an environmental failure: throttling the local network interface, seeding the test database with corrupted UTF-8 characters, or simulating an expired JWT token with valid signatures.
Turn off the AI assistant.
Watch how the junior navigates the unknown: Do they inspect logs? Do they open Wireshark or curl? Do they know how to inspect thread states?
Guide them through the tactile reality of low-level diagnostics. Demystify the magic.
If you are an early-career engineer starting your career in the shadow of generative AI, you face a unique hazard: it has never been easier to feel competent while remaining completely ignorant.
If you spend your first three years merely shepherding prompts, you will wake up in 2030 as an easily replaceable commodity. Anyone can type a prompt. The engineers who will command respect, autonomy, and high compensation are the ones who understand what happens when the prompt's assumptions crumble.
Here is your personal protocol to guarantee you build genuine, senior-grade technical judgment:
Flight students do not rely on autopilot when learning stalls. Turn off autocomplete when learning fundamental concepts.
Shut off AI assistance for at least 5 to 10 hours every week:
When implementing a core domain algorithm, turn the model off.
When writing custom concurrency logic (channels, worker pools, mutexes), write every character by hand.
When learning a new language feature or library, read the official documentation, header files, or language specifications directly.
Embrace the friction. When you sit there for forty-five minutes wrestling with a compiler error or an unexpected type mismatch, your brain is laying down the neural pathways of real expertise. That friction is the training.
Treat AI output like code from an overconfident contractor who cuts corners to close tickets.
Every time an assistant outputs a code block, your first instinct should be asking how to break it rather than verifying the happy path:
What happens if the input array is empty?
What happens if the string contains 10MB of unescaped emojis or null bytes?
What happens if two requests execute this exact block concurrently?
What happens if the downstream dependency throws a socket timeout?
Write hostile test cases that deliberately attempt to blow up the generated logic. If you do not know how to write a test that breaks bad code, you do not have the capability to verify good code.
Frameworks, UI libraries, and ORMs change constantly. LLMs keep up easily with framework churn because internet forums are flooded with millions of repetitive examples of them.
The sub-layers of computing rarely change, and LLMs handle them poorly:
flowchart TB
L1["<b>High-Churn Layer</b> <i>(AI excels, low defensibility)</i><br>React Hooks • Next.js Routing • Express Boilerplate • Tailwind"]
subgraph L2 ["<b>The Durable Sub-Layers</b> <i>(Where real engineering lives)</i>"]
direction TB
B["<b>Operating System:</b> Threads, processes, file descriptors"]
C["<b>Networking:</b> TCP handshakes, TLS overhead, HTTP/2 frames"]
D["<b>Databases:</b> B-Trees, WAL logs, locking, query plans"]
E["<b>Systems:</b> Memory layout, cache locality, CPU contention"]
B --> C
C --> D
D --> E
end
L1 --> L2
If you understand how a PostgreSQL query planner evaluates an index scan versus a sequential scan, you can immediately spot why an AI-generated query will kill production. If you understand how Linux handles file descriptors and epoll, you can diagnose a hung microservice while others are staring blankly at log outputs.
Invest your study time in the durable layers. They will pay dividends for the next thirty years of your career.
Never commit code you cannot explain from first principles on a whiteboard.
If an assistant writes an esoteric regular expression, a clever bitwise trick, or a complex SQL window function, stop. Do not commit until you dissect every token on a scratchpad. If you cannot explain why it works and why an alternative was rejected, you do not understand what you are shipping.
The software industry is not running out of code; it is running out of judgment.
We are running out of engineers who can look at a seemingly functional architectural diagram and immediately spot the single point of failure. We are running out of practitioners who can step into a flaming production outage, ignore the contradictory metric dashboards, and use deductive reasoning to locate a subtle data corruption bug.
AI will extinguish developers who refuse to be more than prompt dispatchers.
The organizations that dominate the next decade will protect the apprenticeship, ensuring new engineers get the manual flight hours they need before facing real production turbulence.
On Friday night, an engineer opens an empty repository, types a sentence into an AI coding assistant, and watches a working SaaS dashboard materialize in three hours. Authentication, database tables, Stripe checkout, responsive charts: everything runs smoothly on localhost:3000. The experience feels intoxicating. "Vibe coding" at its peak makes traditional software engineering look archaic.
On Monday morning, the same engineer opens their team's primary production repository. It contains 140,000 lines of TypeScript, an eight-year-old database schema with legacy triggers, three background job workers, and strict tenant isolation rules.
The engineer types a simple prompt into the assistant:
"Add organization-level workspace switching to the billing dashboard."
Fifteen seconds later, the model outputs 450 lines of idiomatic code across six files. The code compiles without errors. Basic unit tests pass. The developer merges the pull request and deploys to staging.
By Wednesday, the staging environment grinds to a halt:
The query plan broke: The generated code queried active subscriptions inside a render loop, introducing an N+1 database pattern that pushed database CPU to 98%.
Audit trails vanished: The model wrote its own database mutation helper instead of routing updates through the shared compliance pipeline.
Tenant boundaries leaked: The assistant invented an ad-hoc tenant identifier in the session token that clashed with the platform's claims format, displaying workspace names to unauthorized users.
Soft-delete rules failed: The new query filtered by status = 'active', but omitted deleted_at IS NULL, resurfacing accounts removed two years ago.
The assistant did not fail because its code was sloppy. It failed because writing code was never the primary challenge of software engineering.
The Greenfield Mirage
"Vibe coding" succeeds on greenfield toys because an empty canvas has no preexisting invariants to protect. In an enterprise system, prompting an AI without hard specifications acts as an ambiguity multiplier.
On a weekend side project, you carry the entire domain in your head. More importantly, there is nothing in the repo to break:
No legacy schemas to preserve.
No distributed transactions or eventual consistency lag.
No compliance audits, access control lists, or tenant boundaries.
No traffic load to expose subtle concurrency bugs.
If an assistant selects SQLite instead of Postgres, or invents an unusual authentication wrapper, the project still runs. The developer experiences high velocity because the system has zero constraints.
In a production codebase, constraints represent 90% of the engineering work. Real systems survive because they enforce invariants: data stays isolated, mutations leave audit trails, transactions remain atomic, and network calls handle partial failure.
When you prompt an AI assistant without explicit constraints, you ask it to play Russian roulette with those invariants.
Under uncertainty, human engineers and language models behave in fundamentally different ways.
When a human developer receives a ticket that says "Add organization-level switching to billing", they pause. They know the billing service has quirks. They check how authentication tokens carry organization context. They ask the team lead whether deactivated workspaces should appear in the selector dropdown. They surface unspoken assumptions before typing code.
An LLM never pauses. It has no mechanism for hesitation. It resolves ambiguity by fabricating whatever conventions minimize token perplexity, presenting arbitrary architectural choices with complete confidence:
graph TD
classDef prompt fill:#f5f5f5,stroke:#333,stroke-width:2px;
classDef human fill:#e8f5e9,stroke:#2e7d32,stroke-width:2px;
classDef ai fill:#ffebee,stroke:#c62828,stroke-width:2px;
P["Underspecified Prompt:<br/>'Add workspace switching to billing'"]:::prompt
P -->|Human Engineer| H1["Pauses & Identifies Ambiguity"]:::human
H1 --> H2["Checks existing tenant isolation rules"]:::human
H2 --> H3["Asks PM about deactivated accounts"]:::human
H3 --> H4["Writes bounded, safe implementation"]:::human
P -->|Prompt-and-Pray AI| A1["Generates 450 lines instantly"]:::ai
A1 --> A2["Silently invents session format"]:::ai
A2 --> A3["Bypasses shared audit middleware"]:::ai
A3 --> A4["Latent production bug merged"]:::ai
A short, ambiguous prompt does not produce a short, ambiguous response. It produces hundreds of lines of plausible code containing silent architectural decisions you never approved.
As I pointed out in The AI Review Paradox, human comprehension is the true bottleneck. Spotting missing audit logic or an N+1 query buried inside 450 lines of pristine syntax takes twice as much cognitive effort as writing the code by hand.
In 1957, John Backus and his team delivered Fortran. Before Fortran, programming meant mapping operations directly to CPU registers and memory addresses. When compilers arrived, many programmers argued that real engineers needed to write assembly to maintain performance and control.
Compilers did not eliminate software engineering; they moved it up one layer of abstraction. Assembly became an implementation detail. Fortran, and later C, became the language of intent.
We are watching that exact transition happen again.
1950s: Human writes Machine Code / Assembly
1970s: Human writes C / Pascal --> Compiler emits Assembly
2000s: Human writes Java / Python --> Runtime / JIT emits Bytecode
2020s: Human writes Specifications --> AI Agent emits Code
When an agent can synthesize 500 lines of functional TypeScript, Go, or Python in fifteen seconds, imperative syntax is no longer the primary asset. Imperative code is the new assembly language. It is disposable. If a function contains bugs, you do not spend an hour editing its internals line by line; you refine the specification and regenerate it.
The durable asset is the specification: the data models, system boundaries, error semantics, and testable acceptance criteria that define what the software must do.
Writing an engineering specification for an AI agent is not the same as writing an old-fashioned 40-page requirements document. It is a precise technical contract designed to eliminate the assistant's freedom to hallucinate architecture.
Define the environment and the non-negotiables upfront.
Which existing modules must handle this work?
Which shared libraries (audit logging, authentication, database clients) must be used?
What invariants must remain untouched (e.g., "All database queries in this path must include tenant_id and respect soft-deletes via deleted_at IS NULL")?
Tell the agent what not to do. LLMs love speculative generality. Without explicit boundaries, they will refactor adjacent functions, replace date utilities with different libraries, or add unneeded configuration parameters. Stating non-goals keeps the blast radius contained.
Define your types, database migrations, and API schemas before asking for application logic. When data schemas and error models are concrete, the model cannot invent its own data structures.
Treating specs as source code changes how engineers interact with AI assistants. Instead of treating the model as an oracle in a chat window, you use it within a disciplined four-step loop:
Capture the agreed requirements into a markdown document committed directly into the repository (for example, docs/specs/2026-09-28-workspace-billing.md). Include the schema changes, interface signatures, and acceptance tests.
Review this document yourself. If the spec contains ambiguity, fix the spec. Do not hand an ambiguous document to an execution agent.
Verify the agent's work against deterministic tools, not subjective prompts:
Run the compiler and linter.
Execute unit and integration tests.
Verify schema migrations against a local database container.
If a test fails, feed the exact compiler error or test output back to the agent: "Test test_workspace_switching_respects_soft_delete failed with AssertionError on line 42. Fix the query to filter soft-deleted records." The model loops against a concrete failure, not vague conversational feedback.
A decade ago, Agile development declared war on specifications. Teams threw out formal documentation in favor of user stories and sticky notes. In practice, that often degenerated into two-sentence Jira tickets and broken handoffs, a problem I explored in The Waterfall-in-Sprints Trap.
Developers hated specifications because writing 30-page documents in Microsoft Word was slow, tedious, and disconnected from code. By the time a spec made it through committee approval, the requirements had changed and the document was obsolete.
AI code generation creates an ironic twist: it makes specifications practical again.
Drafting, stress-testing, and refining a crisp technical specification with an AI assistant takes twenty minutes. That twenty-minute investment prevents three days of tracking down subtle production regressions caused by hallucinated architectural assumptions.
Typing syntax was never the core skill of a senior software engineer. Syntax recall is a commodity. The enduring craft of software engineering lies in systems thinking: defining boundaries, preserving invariants, anticipating failure modes, and deciding what not to build.
In the AI era, you do not direct systems by typing imperative statements one line at a time. You direct them by writing specifications that make failure impossible.
It is Thursday afternoon on Day 8 of a two-week sprint.
For the first week, the Jira board looked quiet. Then, on Thursday afternoon, six large tickets move into the "In QA" column at once.
The QA engineer opens the first ticket. The description is three sentences long, accompanied by a Figma link where mockups changed two days ago without a note. There are no acceptance criteria, no edge cases, and no mention of how legacy data should migrate.
The tester clicks around. Within twenty minutes, the app crashes on an empty state, silently swallows a validation error, and corrupts a user preference setting.
The tester logs four blocking bugs. The developer pushes back:
"Why are you testing that? Nobody uses that workflow. It works on my machine, and the sprint ends tomorrow."
Meanwhile, the Product Owner worries about the release deadline, and leadership wonders why QA is "always the bottleneck."
Two-Week Mini-Waterfalls
Most teams claiming to practice Agile run two-week micro-waterfalls. They replaced six-month handoff queues with ten-day handoff queues, kept the silos, threw vague requirements over the wall, and left testers to clean up the mess at the end of the sprint.
Scaling software delivery reliably comes down to three things: handoff speed, requirement clarity, and where QA sits in the cycle.
When an engineering organization grows from 5 people to 25 or 50, tribal communication stops working. In response, teams split into specialized roles: Product Owners, Business Analysts, Frontend Devs, Backend Devs, and QA Engineers.
Without deliberate team habits, specialization turns delivery into a relay race:
graph LR
classDef queue fill:#f9f9f9,stroke:#999,stroke-width:1px,stroke-dasharray: 4 4;
classDef stage fill:#e3f2fd,stroke:#1976d2,stroke-width:2px;
PO["PO / Analyst: Writes Spec"] --> Q1["Queue: Waiting for Dev"]:::queue
Q1 --> Dev["Dev: Implements Code"]:::stage
Dev --> Q2["Queue: Waiting for Review & Merge"]:::queue
Q2 --> QA["QA: Manual Verification"]:::stage
QA --> Q3["Queue: Waiting for Release"]:::queue
In a relay race, value only moves when the baton changes hands. Software development breaks down under this model because handoffs across silos create friction:
Context gets lost: Nuance discussed during product discovery rarely makes it into the written ticket.
Work sits idle in queues: A feature that took four hours to code often spends four days waiting in "Ready for Dev", "In Review", or "Ready for QA".
Feedback loops stretch: Finding a requirement flaw in downstream QA costs far more time and rework than spotting it before anyone wrote code.
Building the wrong thing with great precision remains one of the costliest wastes in software delivery.
Vague requirements usually take one of two forms:
The Post-It Note Ticket:"User needs to be able to export audit logs." That is the whole ticket. Does it include archived data? Which roles have permission? What format (CSV, JSON, PDF)? What happens with 500,000 rows? The developer guesses. The tester guesses differently. The PO rejects both during the demo.
The 30-Page PRD Tombstone: An analyst spends two weeks writing an exhaustive document nobody reads to the end. By the time development starts, business priorities have shifted and the document is already out of date.
graph TD
A["Vague Requirement in Ticket"] --> B["Developer fills gaps with assumptions"]
A --> C["QA tests based on different expectations"]
B --> D["Code Merged"]
C --> E["Discrepancy Discovered on Day 9 of Sprint"]
D --> E
E --> F["Blame Game, Rework & Delayed Release"]
Without concrete examples, developers make product and architecture choices on the fly. When QA reports the resulting gaps, developers treat the findings as scope creep rather than missing requirements.
To see how healthy an engineering culture is, look at how the team treats QA.
In struggling teams, QA becomes:
A downstream safety net: A human filter expected to catch typos, missed null checks, and unhandled errors that developers rushed past.
A second-class citizen: Kept out of design reviews, absent from product discovery, and notified only when code hits staging.
The release scapegoat: When a bug reaches production, people ask "Why didn't QA catch this?" instead of "Why did we merge broken code?"
Testing at the End Never Scales
You cannot inspect quality into software after the build is done. When a feature reaches QA loaded with defects and contradictory logic, testers spend their days logging repetitive tickets instead of running exploratory tests or building automated regression suites.
Treating QA as the final checkpoint turns them into an artificial bottleneck. They face a bad choice: rush through test cases under deadline pressure, or take the blame for slipping the release.
Keep developers from picking up tickets based on a bare description alone.
Before estimating a feature or pulling it into a sprint, hold a 15-minute Three Amigos check with three perspectives:
Product Owner or Analyst: Explains the problem and desired outcome ("What business goal does this serve?").
Developer: Evaluates feasibility and constraints ("How does this fit our current architecture? What are the technical risks?").
QA Engineer: Tests the assumptions early ("What happens if the network drops? What about boundary values, permissions, or missing fields? How do we verify this?").
Involving QA before implementation catches half the edge-case bugs as requirement updates on Day 0, rather than blockers on Day 9.
Drop ambiguous statements such as "The form should validate input properly."
Write acceptance criteria as concrete scenarios or tables:
Scenario: User attempts to export audit logs without permission Given a user with role "Viewer"When they request an audit log exportThen the system responds with a 403 ForbiddenAnd an entry is logged in the security monitor
Concrete scenarios give each role a clear job:
The PO confirms the business logic is accurate.
The developer uses the scenarios to guide automated unit and integration tests.
The QA engineer uses them as the base regression suite, leaving room for exploratory testing.
Developers own verification: Developers must write automated tests for the code they commit. Sending a pull request to QA just to see if the main flow works should not pass review.
QA prepares test strategies early: While development is underway, QA should assemble test fixtures, automation scripts, and exploratory test charters.
Pair test during the sprint: Pair on new features as soon as a component runs. A ten-minute walk-through on a local build or preview environment catches issues before they turn into days of Jira ping-pong.
This shift does not require 40-page specifications or heavy sign-off procedures.
It requires moving QA into early refinement, framing requirements around concrete examples, and testing features incrementally as they are built. Doing so eliminates the end-of-sprint panic, protects testers from impossible deadlines, and turns delivery into a steady, predictable rhythm.
You look at the sprint board and see, that one of the developers has two tickets carried over from last sprint. Three more are parked stubbornly in In Progress. Looks like he isn't delivering.
It is tempting to treat a red sprint board as an individual character flaw. It gives management an easy target and a tidy narrative.
But jumping to conclusions without digging into the systemic reality is how good leaders destroy great engineers.
A few years ago, I found myself facing this exact scenario. A senior engineer on my team - someone historically dependable, sharp, and deeply knowledgeable - had been slowly flatlining on the board. Week after week, his sprint commitments dissolved into carryovers. I had to react.
But, when our scheduled 1-on-1 came around, I didn't open Jira. I didn't wave charts or ask why ticket PROJ-412 was running three days late. Instead, I asked one simple diagnostic question:
"Walk me through your week. What is eating your mental bandwidth right now?"
The reaction wasn't defensiveness or excuses. It was a heavy sigh of sheer exhaustion.
The developer wasn't slacking. He was drowning.
He was working 9-hour days, completely drained by 6:00 PM, yet having virtually nothing to show for it on our sprint board. Why? Because his week was dominated by invisible work - a toxic mixture of unlogged side-channel demands and paralyzing ambiguity debt.
He wasn't underperforming. The system was failing him.
When an engineer has deep domain expertise, they become a high-value target for other teams.
Downstream service teams, data pipelines, product managers from adjacent squads - whenever they hit an edge case touching our team's domain, they don't submit a ticket to our backlog. Filing a ticket feels slow, formal, and bureaucratic.
Instead, they slide quietly into the engineer's Slack or Teams DMs:
"Hey, quick question! You know this auth flow inside and out - can you just take a look at why this token validation is failing for our service? Should only take five minutes."
Except it never takes five minutes. It takes thirty minutes of investigation, fifteen minutes of explaining, and an hour to regain deep focus.
Why does the engineer say yes?
Because they care. They want to be helpful, they care about the overall product, and saying "no" feels combative, uncooperative, or obstructionist.
The systemic damage:
Legitimate, company-critical architectural firefighting is being conducted - completely off the books. It is 100% invisible to capacity planning. The engineer burns their mental energy rescuing neighboring teams, and at the end of the sprint, the board brands them an "underperformer" for missing their own assigned commitments.
How developers respond to ambiguity exposes fundamental differences in cognitive and engineering styles:
The "Cowboy" Coder: Makes quick assumptions, writes twenty lines of code, pushes to staging, and moves the ticket to Done. If it breaks an edge case, they'll fix it later. Their velocity looks phenomenal on the board.
The Meticulous Engineer: Understands the downstream architecture. Knows that changing token validation could inadvertently lock out 5,000 legacy mobile clients. Refuses to push unverified guesses into production.
When handed an ambiguous ticket, the meticulous engineer freezes. They spend three days playing forensic detective: digging through three-year-old Git blame logs, deciphering legacy PR comments, and scheduling alignment calls to discover what product actually intended.
The Management Failure
Mistaking an engineer's requirement for clear specifications as a defect in "seniority" or "autonomy" is lazy leadership. Asking for clarity before modifying high-stakes systems is not a lack of independence; it is engineering maturity.
Enforce one non-negotiable golden rule: If it's not in the backlog, it doesn't exist.
Engineers often hesitate to push back on colleagues because they don't want to look unhelpful. Take that social burden off their shoulders:
Provide a ready-to-use deflection script:
Give your team an official, polite response template to paste into Slack or Teams:
"I'd love to help you with this! Since it touches our core domain and impacts ongoing commitments, please pop a quick ticket into our team intake queue so our EM can prioritize it against our sprint capacity."
Act as the social heat shield:
When external leads complain that your engineer isn't answering their DMs immediately, the manager must step in: "Our team is committed to this sprint's delivery. If your request is urgent, let's look at the priority together and decide what on our board gets dropped to make room." Watch how quickly "urgent" five-minute requests evaporate when a trade-off is required.
Budget for cross-team reality:
If your team owns a shared core domain that inevitably generates cross-team questions, stop pretending your sprint has 100% feature bandwidth. Allocate an explicit on-call rotation or dedicated support buffer (e.g., 20% capacity) specifically for triaging external inquiries.
Never allow a half-baked thought to become an active sprint commitment.
Before a ticket enters a sprint, enforce a strict Definition of Ready (DoR):
Context (The Why): What business problem or customer friction does this solve?
Acceptance Criteria (The What): Exactly what conditions must be true for this ticket to be marked Done? What are the verifiable inputs and outputs?
Explicit Non-Goals (What NOT to touch): What is intentionally out of scope? Defining boundaries prevents meticulous engineers from rabbit-holing into adjacent refactoring.
Precision is not micromanagement. Providing clear constraints gives engineers the psychological safety and clarity they need to move with speed and confidence.
Returning to that "underperforming" senior engineer from our story:
Once we put the perimeter shield in place, redirected external drive-by requests through a structured queue, and refused to pull tickets into sprints without clear acceptance criteria, something remarkable happened.
Within two sprints, his delivery metrics completely reversed. Stalled tickets vanished. Velocity surged. He was shipping high-impact code calmly and consistently.
We didn't need a performance improvement plan. We didn't need technical remedial coaching. We didn't need disciplinary lectures.
We simply stopped making him fight an invisible war.
The Leadership Test
A mediocre manager looks at missed deliverables and asks: "Why isn't this person working hard enough?"
A great engineering leader looks at the board and asks: "What in our system is preventing this talented person from succeeding?"
Before you grade an engineer on their output, make sure you haven't forced them to take an invisible exam.