Code Quality · PiniShv

Stop Reviewing Code. Start Reviewing Evidence.

Fri, 10 Jul 2026 12:00:00 +0300

The math went first. Faros telemetry puts hard numbers on what agent-heavy teams already feel: they produce 98% more PRs, 154% larger, and those PRs wait 4.6x longer for a reviewer to even pick them up.

Twice the PRs. Two and a half times the size. Nearly five times the wait before a human even opens the diff.

The pull-request review model, where one busy human reads a diff, understands it, and approves it, didn’t bend under agent volume. It snapped. And the industry’s answer so far has mostly been to tell humans to read harder.

That won’t work, and most of us already know it. The fix for the verification bottleneck is not humans reading more diffs. It is building verification capacity as a system, the way we once built CI. Humans stop reviewing code. They start reviewing evidence.

The bottleneck moved downstream and put on a disguise
#

The generation problem is solved. An MIT study of more than 100,000 developers found code volume up roughly 180% while shipped software rose only about 30%. The constraint is no longer producing code. It is getting code to a state anyone is willing to put in production.

And here is the part that should sting. A LinearB study of 8.1 million PRs across 4,800 organizations found developers feel 20% faster while merged-to-production time is actually 19% slower. Everyone is typing less and waiting more. The keyboard got fast. The gate stayed human-sized.

I wrote before that AI made code cheap to produce, not cheap to own. This is that gap, matured into a full-blown organizational failure mode. Ownership starts at the review gate, and the review gate is where the whole pipeline now piles up.

The human GIL is a correct diagnosis and a terrible strategy
#

Martin Fowler named the problem precisely: the human is the Global Interpreter Lock for agents. Everything the fleet produces serializes through one person’s attention. His advice: don’t launch more agents than you can properly review. Two weeks later he quoted Charity Majors on what happens when you ignore that: “when you ship code faster than engineers can read it… reliability degrades, institutional knowledge evaporates.”

They are right about the failure mode. Zoom out two years and the curve is even steeper: The Pragmatic Engineer reports teams running agents now ship five times more pull requests than they did two years ago, at triple the size, and the same writeup carries a Meta account-takeover vulnerability as the cautionary tale of what merges when volume outruns comprehension. Nobody serious disputes the diagnosis.

But “slow down” is a holding pattern, not a strategy. It caps your engineering organization’s output at the reading speed of its most conscientious reviewers. Forever.

We have seen this exact shape of problem before. Twenty-five years ago the bottleneck was testing. Releases piled up behind manual QA cycles, and the industry’s first instinct was the same one it has now: test harder, run longer QA cycles, slow the releases. That instinct lost. We built CI instead. Nobody today asks a release manager to hand-run the regression suite, and nobody calls that recklessness. We turned verification from a human virtue into a system property.

Bryan Finster put it bluntly: AI broke traditional code review, and the answer is to restructure it rather than heroically read more diffs. I’d go one step further. The review gate has to become something else entirely.

The review gate becomes an evidence gate
#

Here is the reframe I’ve landed on after living with agent fleets in production.

Stop asking humans to verify code. Ask the system to produce evidence, and ask humans to judge it. The evidence gate replaces “a person read the diff” with “the change arrived with machine-verified proof”: failing-then-passing tests, a reproduced bug, validation runs, scope and regression checks. The human rules on the two things machines can’t: intent and architecture.

Call it evidence-based review. The diff is the claim. The evidence is the proof. The human is the judge, not the fact-checker.

Concretely, evidence looks like this:

Reproduction. A bug fix ships with the bug demonstrated failing before the change and passing after it. Not “trust me.” A recorded, re-runnable repro.
Adversarial tests. Tests written to break the change, ideally by a different agent than the one that wrote it. Author-written tests are a conflict of interest whether the author is a human or a model.
Validation runs. The change exercised in a real environment, end to end, with the output attached.
Scope discipline. Proof the diff touches only what the claim says it touches. Agents love to “improve” three unrelated files on the way through.
Regression and blast-radius checks. What else depends on this path, and what happened when the suite ran against it.

None of that requires a human minute. All of it can be produced by the same class of machinery that produced the code. In my own organization, that is the bar I hold the autonomous systems that investigate bugs and write fixes to: a change that arrives without its evidence isn’t “waiting for review.” It isn’t done.

And this is measurable, not hand-wavy. Cognition’s FrontierCode benchmark is the first to score agent PRs on whether a maintainer would actually merge them: correctness, test quality, scope discipline, regression safety, judged by criteria built with more than twenty senior open-source maintainers. Every frontier model passes fewer than half of the hard tasks (the leaderboard leader clears the field by about twelve points and still lands under 50%). Two lessons in one number. First: agents have not earned blind trust, so the gate stays. Second: merge-worthiness can be scored by a machine. If a benchmark can grade correctness, test quality, and scope discipline, your pipeline can demand them.

If your best engineers are your validation layer, you built the system backwards
#

LeadDev documented what agent velocity is doing to the people downstream of it: mid-level engineers silently absorbing unmeasured “invisible validation work,” with one org losing three of them in six to eight weeks while the team shipped 40% faster, right up until the production incidents arrived. A survey of 2,147 engineers found 71% often feel like a middleman between AI output and actual results.

I believe every word of it. I’ve watched the pattern form: the diligent engineers become the org’s immune system, quietly re-verifying everything the agents produce, unmeasured and unthanked, while the dashboard celebrates throughput.

But notice what that actually is. It is not proof that agents don’t work. It is proof that the organization deployed generation capacity without deploying verification capacity, and then made its most conscientious humans eat the difference. The invisible validation work exists because the visible validation system doesn’t.

That’s not diligence. That’s a design flaw with a burnout rate.

The evidence gate is the answer to the middleman problem, not a competitor to it. Every hour a mid-level engineer spends manually confirming that an agent’s fix actually fixes the bug is an hour the system should have spent producing a repro automatically. Humans reviewing evidence instead of re-deriving it is not just faster. It is the difference between judgment work, which builds engineers, and verification drudgery, which burns out exactly the people you need to become your next seniors.

Verification is a system you build, not a virtue you demand
#

If this sounds like the Agentic Overwatch tier model, that’s because it is the same shape. Code review is simply the first engineering ritual to move into the Agent Operations Center. The evidence gate runs in the same three tiers:

Tier 1, evidence production. Agents and deterministic tooling. Every change automatically generates its repro, its adversarial tests, its validation run, its scope and regression report. This is CI’s grandchild: not “did the tests pass” but “here is the complete case for this change.”

Tier 2, adjudication. Agents reviewing agents. A second system cross-examines the evidence: are these tests real or decorative, does the repro actually exercise the bug, did the diff sprawl beyond its claim. Weak cases get bounced back before a human ever sees them.

Tier 3, judgment. Humans. Intent: should this change exist at all? Architecture: does it belong here, shaped like this? Consequence: what’s the blast radius if the evidence lied? These questions don’t scale with lines of code, which is exactly the point. Human attention should never have been scaling with lines of code in the first place.

Fowler is right that human attention is the lock. So stop routing everything through it. Route claims and proofs through it, at the altitude where human judgment actually operates, and let the machinery below grind through the volume the way CI grinds through test matrices.

What to do Monday morning
#

Measure the validation tax. Ask your mid-level engineers how many hours last week went to verifying agent output that nothing tracked. The number will unsettle you. Good. Invisible work stays broken precisely because it’s invisible.

Define evidence requirements per change class. A bug fix ships with a reproduction. A refactor ships with regression proof. A dependency bump ships with a blast-radius report. Write it down like you once wrote down test-coverage rules. No evidence, no review slot.

Build the evidence harness before you scale the fleet. Every agent lane you launch without automated evidence production is another engineer conscripted into middleman duty. Verification capacity first, generation capacity second. Most orgs did it in exactly the wrong order, which is how we got here.

Retrain the reviewer role. Your reviewers stop being line-by-line readers and become adjudicators: they rule on whether the evidence supports the claim and whether the change deserves to exist. That is a promotion, not a demotion. It is also the Tier 3 skill your whole agent operation will run on.

The teams that keep the human as the interpreter lock will spend the next two years choosing between capped velocity and quiet reliability decay, while their best people burn out doing verification work no dashboard sees. The teams that build the evidence gate get the volume and the trust.

Code review isn’t dying. It’s being promoted, from reading the work to judging the case.

Stop reviewing code. Start reviewing evidence.

How is your team handling review under agent volume? Whether you’re drowning in diffs or already building the evidence machinery, I want to hear what’s working. Find me on X, LinkedIn, or Telegram.

The Vibe Coding Backlash Is Right. Seniors Are Losing the Argument Anyway.

Fri, 24 Apr 2026 14:00:00 +0300

Something finally broke this week. Forbes published Vibe Coding Will Break Your Company. Senior engineers are circulating it. Other senior engineers are writing their own versions. The pushback on vibe coding culture has been brewing for months, and it just hit mainstream media.

The seniors are right. And they’re about to lose the argument anyway.

Here’s why, and what needs to happen if they actually want to win it.

What the seniors are right about
#

The data at this point isn’t close.

Multiple independent audits of AI-assisted codebases are converging on the same picture: AI-co-authored code ships with materially more “major” issues than human-written code. Audits of no-code AI app-generation platforms keep finding meaningful percentages of generated applications going live with real security holes: hardcoded API keys, client-side-only authentication, unsanitized user inputs.

In July 2025, a Replit AI agent deleted a live production database during an explicit code freeze, affecting over 1,200 executive users. The agent had permissions. The permissions were never meant for an agent. Nobody designed for the possibility.

Across the industry, Stack Overflow’s trust-gap research and DX’s Q1 2026 impact report tell the same story: 84% of developers use AI daily. Only 29% trust the code reaching production. PR throughput is up 46% in some teams. Defect rates are up 50% in some of the same teams.

And the perception gap keeps embarrassing us. METR’s study measured experienced developers as 19% slower with AI while they believed they were 20% faster. 39 percentage points of self-deception. The feeling is real. The feeling is wrong.

The craft didn’t change. The pressure to ship faster without understanding what shipped did. And when you ship what you don’t understand, you pay for it later, with interest. The next generation of senior engineers is taking the brunt of it.

The seniors are not wrong to push back. They’re watching production systems rot in slow motion.

What the vibe coders are also right about
#

For a lot of what companies actually ship, fast-and-rough is genuinely fine. Internal tools nobody will maintain in two years. One-off data migrations. Prototype features for customer calls. Throwaway scripts. The economics of fussing over these pieces changed. If an agent ships them in thirty minutes and they work, that’s a real win.

The vibe coders are also right that a lot of “senior engineering rigor” is muscle memory from an era where code was expensive to produce. Gatekeeping code review, nit-level style comments, architectural debates that take longer than the feature itself. Some of it was always noise. More of it is noise now that the economics flipped.

And they’re right that the pushback often sounds like resistance to change from people protecting their role.

Both sides are right about different things. The fight isn’t which side wins. It’s where the line gets drawn.

Why the seniors are losing anyway
#

In most engineering orgs, the pushback against vibe coding is losing. Not because the data is wrong. Because the seniors can’t make their case in the meetings where throughput metrics get shown.

Imagine the scene. Quarterly review. Director pulls up a dashboard.

PR throughput: up 46%
Commits per engineer: up 2.1x
Features shipped: up 34%
Deployment frequency: up

Then the senior engineer raises a hand and says “but the code quality is degrading.”

Where’s that dashboard? What’s the number? Can you point to the specific incidents that didn’t happen because you caught them in review? Can you show the rework that wasn’t done because you stopped a bad architecture at design time?

Usually, no. The senior engineers have the instinct and the experience. They don’t have the receipts.

Throughput is legible. Judgment is invisible. In a fight between legible and invisible, legible wins every time.

This is the real problem. The seniors are right, and they’re losing, and they’re losing because the thing they’re right about doesn’t show up on the charts.

What “legible judgment” actually means
#

In organizations doing this well, the senior engineers who keep winning this argument don’t do it by being louder. They do it by making the prevented damage visible. Five concrete moves.

Write down the decisions you stop from shipping. When you block a PR because the approach is wrong, don’t just close it. Write a one-line note: “Rejected: would create a race condition under load. Suggested redesign: queue-based.” Collect these. After six months, you have a measurable “incidents prevented” count. That’s a number. Numbers win.

Track rework on AI-generated code specifically. Most PR analytics can’t distinguish AI-generated from human-written code. If yours can, instrument it. Show the quarterly trend: what percentage of AI-generated commits get reworked within 30 days? If it’s higher than your human-written baseline, that number is your argument.

Tie blocked architectures to real incident data. When an incident happens that a senior flagged earlier, say so in the postmortem. Not as blame. As calibration data. “This failure mode was identified in PR #1847 on March 3 and was not addressed before ship.” That’s the receipt.

Put a senior on every AI-native system’s design review, not just the code review. Code review is too late. By then the architecture is set and the only conversation left is stylistic. Design review is where senior judgment actually prevents expensive mistakes. Move your seniors upstream.

Run quarterly “prevented incident” retros. Once a quarter, the senior engineers present what they caught and the counterfactual. What would have happened if this had shipped? What did it cost to catch it? That reframes senior time as prevention, not overhead.

The bigger reframe
#

The vibe coding debate is a symptom. The underlying issue is that engineering organizations built their scorecards for a world where code production was the bottleneck. In that world, throughput meant progress.

That world ended sometime around late 2024. The bottleneck isn’t production anymore. It’s ownership. Review capacity. System understanding. Architectural coherence across the full surface area. Governance. Incident response.

If your scorecard only measures production throughput, you will systematically underfund the ownership layer. The senior engineers trying to protect that layer will keep losing quarterly reviews while the on-call pager gets louder.

The seniors aren’t wrong. The scorecard is.

What senior engineers should do right now
#

Three moves, in order.

Stop arguing about vibe coding. The debate is a distraction. Every hour spent defending “slow careful engineering” in principle is an hour not spent proving prevented cost in practice.

Start a prevented-incident log today. One line per blocked PR, rejected design, caught architectural issue. Share it monthly with your manager, not as complaint, as data. Six months from now you’ll have a case you can actually make.

Volunteer for the AI incident response playbook. When the next AI agent deletes something important (and it will), be the person with the playbook. Incidents shift organizational gravity. You want to be the person organizations call, not the person who said “I told you so.”

The seniors who survive this era will not be the ones who pushed back the loudest. They’ll be the ones who learned to make their judgment measurable, visible, and impossible to dismiss when the throughput chart is on screen.

The vibe coders are going to keep shipping. That’s fine. The question is who’s going to own what they ship in production three months later. That’s the open job. If you’re a senior engineer, that’s your job. Go take it.

What prevented-incident data do you actually have from the last quarter? Find me on X, Telegram, or LinkedIn.

Disclaimer: This article references specific studies, surveys, and public commentary for illustrative and educational purposes, including work from Forbes, Stack Overflow, DX, METR, Medium authors, Replit and Lovable incident reports, and industry analyses available at the time of writing. I have not independently verified all claims. The analysis and opinions expressed are my own. I have no financial interest, business relationship, or affiliation with any companies or tools mentioned. This is commentary, not investment, legal, career, or business advice.

AI Makes Code Cheap to Produce. Not Cheap to Own.

Thu, 02 Apr 2026 12:00:00 +0200

Here’s the gap that should worry engineering leaders more than any single AI incident.

AI made code dramatically cheaper to produce. Boilerplate, scaffolding, internal tools, glue code, first-pass implementations. All faster. I’ve written about this before and I believe the speed is real.

But the cost of owning code didn’t drop at the same rate. Some of those things got faster too. CI pipelines, SAST, dependency scanning, automated testing. The tooling exists. But having the tools and actually making them the focus are different things. Most teams automate the easy checks and skip the hard ones. And when code volume doubles, even the automated parts need more attention than they’re getting.

The gap between production speed and ownership capacity is where organizations get hurt.

What the data says
#

Sonar’s developer survey puts numbers on it: 72% of developers who have tried AI use it daily. AI accounts for 42% of committed code. But 96% don’t fully trust the output, and only 48% say they always verify AI-assisted code before committing.

Half the code isn’t being verified by the people who committed it. That’s not a tooling problem. That’s a discipline gap.

On the security side, Veracode found risky security flaws in 45% of tests across more than 100 models. Georgetown CSET found that almost half of AI-generated snippets contained bugs that were often impactful. GitGuardian’s 2026 report detected 28.6 million new secrets in public GitHub commits in 2025, a 34% increase year over year, with AI-assisted commits leaking secrets at roughly twice the baseline.

On code quality, GitClear’s analysis found more cloned code, less refactoring, and more short-term churn. A January 2026 study on autonomous coding agents found static-analysis warnings rising 18% and cognitive complexity up 39%.

None of this says AI is useless. All of it says code production is accelerating faster than code governance.

Where it breaks
#

The pattern I keep seeing looks the same across organizations.

AI generates code quickly. The PR looks good. The tests pass (if there are tests). The review is fast because the diff is large and the reviewer is busy. It ships. It works. For now.

Three months later, someone needs to modify that code and can’t understand it because nobody on the team wrote it in a way they’d naturally reason about. Or a dependency it pulled in has a vulnerability. Or a license obligation nobody noticed is now a legal question. Or the secrets it embedded are in a log somewhere.

The cost doesn’t show up at generation time. It shows up at ownership time. And by then, the team that generated it has moved on to the next sprint.

DORA’s 2025 AI report found a negative relationship between higher AI adoption and delivery stability. Their recommendation is one of the oldest engineering lessons: small batch sizes. AI can generate massive blocks of code that are hard to review and test. Small batches plus strong automated testing are the counterweight.

What to change
#

Same gates for all code. AI-generated code goes through tests, review, linting, SAST, dependency scanning, secret scanning, and license checks. No exceptions. The standard is “would we be comfortable owning this in production?”

Small batches, always. Resist the temptation to let AI generate a 500-line PR. Break it up. Review it in pieces. The speed gain from generation is worthless if it creates a review and maintenance bottleneck downstream.

Track provenance. If you can’t answer what third-party components entered through AI, what licenses apply, and who owns the output, you don’t understand what you shipped.

Measure ownership, not output. Escaped defects. Rework rate. Time-to-understand for someone new. Rollback frequency. These tell you whether code is owned, not just produced.

Budget for the ownership layer. If your team is spending 80% of its capacity generating code and 20% on everything else, flip that conversation. The generation is the cheap part now. The ownership is where the investment needs to go.

The one-line version
#

AI made the first draft cheap. It didn’t make the second year cheap. Plan accordingly.

How is your team handling the gap between code production speed and governance capacity? I’d love to hear what’s working. Find me on X or Telegram.

AI Didn't Replace Software Engineering. It Made Bad Engineering Easier to Ship.

Sun, 22 Mar 2026 00:00:00 +0000

Something shifted in the last year and I don’t think enough people are talking about it honestly.

“Ship fast with AI” became the default expectation. Not just in one company. Everywhere. I hear it in conversations with other engineering leaders, I see it in open source repos, I notice it in how people talk about engineering work online. The assumption is that if you’re not shipping faster with AI, you’re falling behind. And if you push back, if you slow down to ask whether anyone actually understands what shipped, you look like you’re blocking progress.

Engineering discipline became a career risk. That’s the shift.

Not because AI is bad. I’m pro-AI. I want teams using it aggressively. But the culture around it drifted somewhere dangerous: we started treating speed as proof of quality, and nobody corrected the mistake because the dashboards looked great.

How the rot works
#

Here’s the chain reaction I keep seeing play out.

It starts with the culture. Leadership sets the tone: adopt AI, move faster, ship more. That’s reasonable. AI does make the mechanical parts of software cheaper. Boilerplate, scaffolding, migrations, glue code, first-pass implementations. All dramatically cheaper now. One strong engineer with the right tools can burn through work that used to take days. That part is real, and teams that ignore it are choosing to be slower for no reason.

But then the culture starts rewarding output over understanding. The engineer who ships three features in a sprint looks more productive than the one who shipped one but thought deeply about failure modes, tested edge cases, and refactored the interface. The first engineer gets praised. The second one gets asked why they’re slower than their peers.

That’s where discipline starts to erode. Not because engineers are lazy. Because the system is telling them that slowing down to think is unproductive. The incentive points at speed, so speed is what you get.

And the quality problems follow, quietly. A January 2026 study on autonomous coding agents found static-analysis warnings rising 18% and cognitive complexity increasing 39%. The researchers called it “sustained agent-induced technical debt even when velocity advantages fade.” That maps exactly to what I see: the code looks fine on the surface, the PR gets approved, the feature ships, and the complexity accumulates in places nobody is watching.

On the security side, recent data shows AI-assisted commits leak secrets at about 2x the baseline rate. Not because the tool is broken. Because humans under time pressure make worse decisions. Speed without discipline creates exposure.

Meanwhile, nobody connects the dots. The velocity charts are green. The sprint burndown looks healthy. But the on-call rotation gets heavier. Rollbacks creep up. The feature that shipped in two days takes two weeks to debug. The Plandek 2026 benchmarks across 2,000+ teams confirmed the pattern at scale: as coding speeds up, the bottleneck just shifts downstream to review, testing, and integration. The slow teams are still slow. They’re just slow in different places now.

And the skill problem compounds it. Anthropic ran a randomized trial where developers learning a new library with AI scored 17 percentage points lower on mastery than those who learned without it. The largest gap was in debugging. The exact skill you need most when AI-generated code breaks. If your engineers aren’t building real understanding, you’re growing people who can ship fast but can’t fix what they shipped.

The whole chain is connected. Culture rewards speed. Speed without understanding produces fragile systems. Fragile systems produce incidents. Incidents expose the gap. But by then, the culture has already moved on to the next sprint.

The perception gap
#

Here’s what makes this so hard to catch from the inside.

Last year, METR ran a study where experienced developers using AI were measured at 19% slower, while believing they were 20% faster. When they tried to rerun it with better tools, developers refused to participate if it meant working without AI. They’re now redesigning the entire experiment because measuring this honestly is harder than anyone expected.

I don’t think the specific numbers matter as much as the pattern: people feel faster. The feeling is real. But feeling and measurement aren’t the same thing. And in a culture that rewards feeling fast, nobody wants to be the person who says “slow down, let’s check.”

Thoughtworks landed on something important in their February 2026 retreat: AI is actually increasing cognitive load, not reducing it. More output, more concurrent problems, more decisions to make. Same human judgment capacity.

Stack Overflow has been tracking what they call the AI trust gap: adoption keeps climbing, trust keeps falling, and the top developer frustration is “almost-right” code that takes longer to verify and fix than it saved to generate.

Everyone knows this. Nobody wants to be the one who says it out loud, because the culture has made saying it feel like resistance.

Most AI agendas are still theater
#

This is the part where I’m going to annoy some people.

A lot of company “AI strategies” aren’t strategies. They’re tool rollouts with executive branding. Buy licenses. Mandate adoption. Count prompts. Celebrate throughput. Post a screenshot in the all-hands. Hope quality survives.

That’s not transformation. That’s procurement.

If your AI agenda starts with “every engineer must use Tool X” and ends before you redesign review standards, testing expectations, security boundaries, knowledge capture, and learning paths for junior engineers, then all you did was change the keyboard.

You didn’t modernize engineering. You industrialized guesswork.

And if the KPI you’re showing upstairs is “percentage of code written by AI”?

That’s one of the dumbest vanity metrics engineering has ever produced.

I don’t care how much code the model wrote. I care whether we understand what we shipped. I care whether it survives production. I care whether the team is getting better, not just faster.

Simon Willison drew the right line between vibe coding and what he now calls “agentic engineering.” If you reviewed, tested, and understood the AI-written code, that’s still software development. The production-grade version of working with AI raises the bar for tests, planning, docs, automation, QA, and review. It doesn’t lower it.

The problem is that a lot of teams adopted the speed without adopting the bar.

What actually needs to change
#

I’ve written before about how the work sequence shifts and what to do about junior engineers in earlier articles. This piece is about the organizational layer, because that’s where the failure is concentrated right now.

Separate prototype mode from production mode. Loose AI prototyping is great for throwaway experiments. It doesn’t belong anywhere near money, customer data, security boundaries, or core workflows.

Make AI transparency normal. If a change was heavily AI-assisted, say so. Show the verification path. Reviewers should know whether they’re looking at a handcrafted change, an AI-assisted draft, or an agent-produced branch. Different creation paths deserve different scrutiny.

Review decisions, not just diffs. Ask why this approach exists. What breaks first. What alternatives were rejected. What do we monitor. If your review culture is still optimized for nit-picking while AI is generating whole subsystems, your process is in the wrong decade.

Measure what matters. Escaped defects. Rework rate. Rollback frequency. MTTR. Time-to-understand for someone new in the codebase. A green AI usage dashboard isn’t evidence that your architecture got better.

Stop rewarding speed without understanding. This is the culture change that matters more than any tool or process. If your system promotes the engineer who ships fastest and ignores the one who catches the architectural flaw before it ships, you’re building the wrong incentives for the AI era.

But honestly? The most important thing you can do isn’t on this list.

Sit down with your team and have an honest conversation about what you actually understand versus what you shipped. Not a retro. Not a metrics review. A real conversation. What did we ship this month that we could confidently debug at 2 AM without the AI? What would break if the model hallucinated something subtle? Where are we trusting output we haven’t verified?

If that conversation is uncomfortable, good. That’s the conversation that needed to happen three months ago.

The craft didn’t change
#

AI changed the toolkit. It changed the speed of first drafts. It changed the sequence of when work happens. It changed how much mechanical effort one good engineer can burn through in a day.

But it didn’t change the craft.

We’re still in the business of turning ambiguity into reliable systems. Still responsible for the trade-offs. Still accountable when the thing breaks. Still need people who understand architecture, testing, operations, failure modes, and human consequences.

The teams that win won’t be the ones that generate the most code. They’ll be the ones that still know what good engineering looks like when the machine gets loud. The ones where discipline isn’t a career risk. The ones where slowing down to think is treated as engineering, not obstruction.

The tool changed. The accountability didn’t.

What’s the worst AI-caused quality problem you’ve seen? Not a hypothetical. A real one. I’d genuinely like to hear it. Find me on X or Telegram.

Disclaimer: This article references specific companies, products, research studies, and industry analyses for illustrative and educational purposes. Information is based on publicly available sources including METR, Plandek, Anthropic, GitClear, GitGuardian, Stack Overflow, and Thoughtworks reporting, available at the time of writing. I have not independently verified all claims. The analysis and opinions expressed are my own. I have no financial interest, business relationship, or affiliation with any companies mentioned. This is commentary, not investment, legal, or business advice.

Code Quality · PiniShv

Stop Reviewing Code. Start Reviewing Evidence.

The bottleneck moved downstream and put on a disguise #

The human GIL is a correct diagnosis and a terrible strategy #

The review gate becomes an evidence gate #

If your best engineers are your validation layer, you built the system backwards #

Verification is a system you build, not a virtue you demand #

What to do Monday morning #

The Vibe Coding Backlash Is Right. Seniors Are Losing the Argument Anyway.

What the seniors are right about #

What the vibe coders are also right about #

Why the seniors are losing anyway #

What “legible judgment” actually means #

The bigger reframe #

What senior engineers should do right now #