Everybody agrees the AI code review bottleneck is real. Then go look at the org chart.

The AI code review bottleneck is the one thing everybody in this industry currently agrees on. Making things got cheap. Checking them did not. You will hear it in every conference talk and every leadership meeting this year, usually with a slide. And then you go and look at the actual org chart, and there is nobody on it whose job this is. Not a person, not a title, not a line in the budget. We all agree it is the most important work in the building, and we have assigned it to no one.

Try the Org Chart Test Yourself

Go pull up your own company’s open roles. I will wait.

You have a Head of Platform. You have a Head of Developer Experience. Somewhere there is a Head of Growth with a very nice deck.

Now find me the person responsible for whether any of it is true.

There is no title. There is no interview loop. There is no promotion criteria that says this person caught eleven expensive mistakes before they left the building. There is no salary band, because there is no band for a job nobody named.

We invented the most important role of the decade and then forgot to create the job posting.

So the work lands on whoever happens to be paranoid that week. Which works, right up until that person is on vacation, or leaves, or finally gets tired of being the only one who reads things.

Paranoia is not a staffing plan. It is a personality trait, and personality traits do not show up in the budget.

Why It Stays Invisible

Here is the cruel bit, and it explains most of the problem.

Verification produces nothing you can demo. You cannot screenshot the outage that did not happen. There is no launch party for the thing that quietly did not catch fire.

The person who ships a feature gets a slide with their name on it. The person who noticed the feature would corrupt the invoicing table gets to say so in a meeting, briefly, and then everyone moves on, mildly irritated at the delay.

Do that for two years and see how you feel about raising your hand.

Verification is the only job where doing it perfectly looks exactly like doing nothing at all.

So the incentive gradient runs the wrong way, and the incentive gradient always wins eventually. Nobody sat in a room and decided to stop checking things. It just quietly became the cheapest corner to cut, one sensible quarter at a time.

The Bill Arrives Later, With Interest

A little while ago I wrote about a gentleman whose checkout page had been slow for six months, and how we found the culprit in seventy five minutes. I am not going to tell that story twice. I want to point at one thing in it that I glossed over at the time.

That was not a performance tuning engagement.

Nothing about it required deep expertise. The server had been complaining loudly and in plain language for half a year, in a place anybody on that team could have looked. What it required was four uninterrupted hours in which somebody’s only job was to look. That is a verification engagement wearing a performance tuning hat.

Six months of part time guessing lost to one afternoon of full time looking. Not because I am clever. Because for one afternoon, checking was somebody’s actual job, and for the six months before that it had been nobody’s.

Everybody on that team had a theory. Not one of them had a measurement, and a theory without a measurement is just a rumor wearing a lab coat.

Five Things That Cost Almost Nothing

You do not need to hire a Chief Verification Officer. Please do not hire a Chief Verification Officer. But you do need to stop pretending this happens by itself.

Name the owner out loud. Not a team. A person, on the page, for this change. Shared responsibility is the polite name for nobody.

Put hours in the plan. If the estimate has build time and no check time, the check time is zero, whatever anyone says in the meeting. Write the number down. Defend it like you would defend anything else.

Measure time to catch. Not bugs found, which just punishes the honest. How long did the mistake live before somebody noticed? That number is the health of your whole system, and almost nobody tracks it.

Make the review a deliverable. Not a courtesy someone squeezes in before lunch. It has a name, an owner, an output, and a place to live. Courtesies get cut. Deliverables get done.

Say thank you in public. Out loud, in front of everyone, to the person who slowed you down and was right. That one costs nothing and changes more behavior than any process document you will ever write.

If Any of This Sounds Familiar

Maybe you have your own six month story. A problem that gets a fresh bandage every few weeks and somehow never heals. Everybody has a theory. Nobody has had four uninterrupted hours to look.

That is exactly what the Comprehensive Database Performance Health Check is. Four focused hours of somebody whose entire job, for that afternoon, is to check. I never ask for your password. Every script goes home with your team, so you never need me again. Fixed price, agreed before we start, no surprises hiding in the bill.

And if you would rather do it yourself, genuinely, do it yourself. The point of this post is not that you should call me. The point is that somebody has to be assigned, on purpose, with hours on the calendar, or it does not happen. It never once happened by accident in twenty five years.

Verification Is the New Bottleneck is one of the thirty essays in my book AI: Nobody’s in There. But we’re still in here. When I wrote it I thought the hard part was convincing people it was true. It turns out everybody already believes it. They just have not put it on the org chart, which is a very different problem and a much more fixable one. The essays are free to read at pinaldave.com, with a paperback on Amazon.

So go look at your org chart this week, and find the box that says who checks. If there isn’t one, you have not found a gap in your process. You have found the gap where your next six month story is going to grow.

Checking was never the tax on the work. It is the only part of the work that was ever actually yours.

Reference: Pinal Dave (https://blog.sqlauthority.com/), X

First appeared on AI Code Review Bottleneck: Nobody Owns It

This is a potentially big performance optimization you can opt into starting with Marten 9.0. Not coincidentally, we’re using this for CritterWatch to help optimize the responsiveness and database size for a JasperFx client this week.

Marten can serialize individual event types to a binary wire format (MemoryPack, MessagePack, or anything else implementing IEventBinarySerializer) instead of the default JSON, trading a few of JSON’s ergonomic wins for a meaningful throughput and storage-size improvement on hot streams. See #4515 for the design discussion.

The opt-in is per event type — binary-serialized and JSON-serialized events coexist in the same mt_events table, so the feature can be rolled out on an existing store with no migration of existing data.

How it works

A second column, bdata bytea NULL, sits alongside the existing data jsonb NOT NULL on mt_events. The row-level discriminator is bdata IS NULL:

On read, Marten inspects bdata:

• NULL → existing JSON deserialization path. Pre-feature rows continue to work without conversion.
• non-null → IEventBinarySerializer.Deserialize(eventType, bytes).

Because the discriminator is on the row and the serializer is resolved per event type, the same stream can carry rows of either format with no special handling at the call site.

Quick start with Marten.MemoryPack

The companion Marten.MemoryPack NuGet package ships a ready-to-use IEventBinarySerializer over MemoryPack:

dotnet add package Marten.MemoryPack

Mark event types you want to serialize as binary with both [BinaryEvent] (so Marten picks them up) and [MemoryPackable] (so MemoryPack can serialize them):

using Marten.Events;
using MemoryPack;
[BinaryEvent]
[MemoryPackable]
public partial record TripStarted(Guid TripId, string DriverName, DateTimeOffset StartedAt);

Wire MemoryPack as the store-wide fallback for [BinaryEvent] types:

using Marten.MemoryPack;
var store = DocumentStore.For(opts =>
{
    opts.Connection(connectionString);
    // Wire MemoryPack as DefaultBinarySerializer. [BinaryEvent]-marked
    // event types resolve to this serializer on registration. Works with
    // every EventAppendMode (Rich / Quick / QuickWithServerTimestamps)
    // and with BulkEventAppender — see the "Append modes" section.
    opts.Events.UseMemoryPackSerializer();
});

Now TripStarted writes through MemoryPack to bdata; un-marked events continue to write JSON to data.

Registration ergonomics

Two equivalent ways to opt an event type in:

// 1. Attribute-driven — uses opts.Events.DefaultBinarySerializer as the resolver.
[BinaryEvent]
[MemoryPackable]
public partial record TripEnded(Guid TripId, DateTimeOffset EndedAt);
// 2. Fluent — wire an explicit per-type serializer (overrides any default).
opts.Events.UseBinarySerializer<TripEnded>(new MemoryPackEventSerializer());

Resolution order on EventMapping construction:

1. Explicit opts.Events.UseBinarySerializer<TEvent>(...) for that type.
2. [BinaryEvent] attribute + opts.Events.DefaultBinarySerializer.
3. Otherwise, plain JSON (existing path).

If a type carries [BinaryEvent] but no per-type serializer was wired AND DefaultBinarySerializer is null, Marten throws at the first append with a remediation message naming both registration entry points.

Bring your own serializer

IEventBinarySerializer is small enough to implement directly against any binary format — MessagePack, protobuf, etc.:

public interface IEventBinarySerializer
{
    byte[] Serialize(Type type, object data);
    object Deserialize(Type type, byte[] data);
}

The serializer is a singleton — keep its state thread-safe.

On-disk shape

For binary events, data holds the literal {} placeholder so the existing data jsonb NOT NULL constraint stays intact (no schema relaxation):

-- binary-serialized event
select type, data::text, bdata is null
from mt_events where seq_id = 42;
--    type        | data | bdata is null
-- --------------|------|---------------
--  trip_started | {}   | false
-- JSON-serialized event in the same stream
select type, data::text, bdata is null
from mt_events where seq_id = 43;
--    type                | data                            | bdata is null
-- --------------------- |---------------------------------|---------------
--  trip_comment_added   | {"comment": "looking good", …}  | true

Migration

Purely additive: the only schema change is bdata bytea NULL on mt_events. Existing rows have bdata = NULL (the column’s default for prior data) and read through the JSON path. Marten’s standard schema migration creates the column for existing installations — no event data conversion required.

Append modes

Binary event serialization works with every EventAppendMode Marten ships — Rich, Quick, and QuickWithServerTimestamps. The Quick modes route appends through the mt_quick_append_events PostgreSQL function, which carries a bdatas bytea[] parameter that’s inserted into mt_events.bdata in parallel with the existing bodies jsonb[]. BulkEventAppender (the COPY-based bulk loader) also supports binary events — its COPY column list includes bdata, and each event row writes either the binary payload or NULL.

You don’t have to think about the append mode: binary opt-in is per event type and works identically across all of them.

Schema evolution — use versioned event types

Marten’s existing event upcasters operate on the JSON wire form and don’t generalize to a byte[] payload, so they don’t apply to binary events. The recommended pattern for evolving a binary event’s shape is introduce a new event type for each version rather than upcasting in place:

// Original
[BinaryEvent]
[MemoryPackable]
public partial record TripStarted(Guid TripId, string DriverName);
// Schema change — new fields. Don't edit TripStarted; add a new type.
[BinaryEvent]
[MemoryPackable]
public partial record TripStartedV2(Guid TripId, string DriverName, DateTimeOffset StartedAt);

When the projection / aggregate handles both versions explicitly, old streams keep replaying through the old type and new appends use the new type:

public class Trip
{
    public Guid Id { get; set; }
    public string DriverName { get; set; } = "";
    public DateTimeOffset? StartedAt { get; set; }
    public void Apply(TripStarted e)   { Id = e.TripId; DriverName = e.DriverName; }
    public void Apply(TripStartedV2 e) { Id = e.TripId; DriverName = e.DriverName; StartedAt = e.StartedAt; }
}

The coexistence design lets old rows (written as TripStarted) and new rows (written as TripStartedV2) live on the same stream without migration.

Why not in-place backward-compatible schema changes?

You can lean on MemoryPack’s backward-compatible field evolution ([MemoryPackOrder], nullable fields, the VersionTolerant mode) for additive-only changes to a single event type. That works as long as the serializer itself can deserialize old payloads into the new shape — but the moment a change goes beyond the serializer’s tolerance rules (renaming, type changes, splitting a field), there’s no JSON-style upcaster path to fall back on. Versioning the event type works for every shape of change and stays explicit about which version each row was written with.

Mixing binary + JSON

If you have an existing JSON-serialized event and want a future version to go binary, the same pattern applies: define a new [BinaryEvent]-marked type for the new version, leave the old (JSON) type and its upcasters alone, and have the aggregate handle both. The per-row dispatch already copes with mixed formats on the same stream.

See also

• Optimizing Event Store Performance and Scalability
• Event Versioning (JSON upcasters)

Microsoft posted its Fiscal Year 2026 Fourth Quarter earnings on July 29, and revenue hit $90 billion for the quarter, up 18%, and Microsoft Cloud crossed $214 billion for the full year. Of course, all this means nothing unless you’re an investor.

But buried in Satya Nadella’s prepared remarks, though, was one sentence worth of good news about Windows 11 that will shape how the OS looks and feels for us.

Windows didn’t get much airtime on the call, which isn’t unusual. The segment that houses it, Personal Computing, declined 4% for the quarter, with Windows OEM revenue down 7%. But right before moving on to search and LinkedIn, Nadella said this about Windows:

“In Windows, we are investing to ensure that it has the best quality and fundamentals”

Windows 11 had a rough 2025, and Redmond knows it. Back in March, the company promised to fix Windows 11’s fundamentals after a year of broken updates, and a lot of that promise has shown up in Insider builds and stable updates since.

However, Nadella, being a man of numbers and systems, mentioning investing in quality and fundamentals in Windows on the day investors are grading the company, just tells us that the software giant has a lot in store for making Windows 11 better.

What “best quality and fundamentals” means for Windows 11

This isn’t the first time Nadella has said something like this. During the Q3 2026 earnings call in April, he admitted Microsoft needs to “win back” Windows fans, specifically calling out performance work for low RAM PCs, a streamlined Windows Update experience, and a return to “core features and fundamentals that matter most to our customers.”

Four months later, the language has narrowed to just two words, quality and fundamentals, but the stakes are higher, especially with the company admitting later in the earnings call that Windows OEM revenue will decline in the high teens for the coming fiscal year.

Some of what “fundamentals” covers is already visible. Microsoft has been rebuilding legacy Windows 11 UI in WinUI, with the File Explorer Properties dialog getting a recent update, and confirmed plans to bring more of the OS onto the framework.

But WinUI itself still has RAM and performance problems Microsoft is working through before the bigger pieces, like the Start menu, can move onto it. Nadella calling out fundamentals suggests that work isn’t slowing down anytime soon.

Nadella has spent a decade quietly pulling Windows out of the spotlight

We’re now used to Windows getting a single sentence on an earnings call, despite knowing that it’s the OS that made the company into a household name, or rather a workplace standard. It’s basically been Nadella’s approach to Windows since he became CEO in February 2014.

Nadella’s very first strategic pitch as CEO was “mobile-first, cloud-first,” a phrase that, deliberately or not, didn’t include Windows at all. In his book Hit Refresh, he wrote about realizing the world had moved on from Windows and about restructuring Microsoft’s engineering teams around cloud and AI instead of the OS. Windows 10 shipped as a free upgrade in 2015, less a product launch than a way to unify Microsoft’s install base and push it toward subscriptions and cloud services.

Microsoft’s commercial cloud revenue was under $3 billion when Nadella took over in 2014. Azure grew 43% this quarter and crossed $100 billion annually, while the Windows-containing segment shrank. Windows still runs on more than a billion devices, but it’s Azure, Microsoft 365, and Copilot doing the heavy lifting on Microsoft’s income statement now, not the OS.

Can we trust Microsoft to fix Windows 11?

A lot of readers, understandably, don’t take Microsoft’s word for it anymore. But this year has had a real stream of quality and fundamentals updates for Windows 11, and there are still five months left in the calendar year to add more.

Two things that I would like to point out:

1. Microsoft has already proven it’s capable of fixing Windows 11 this year, the same way it proved in 2025 that it’s capable of running the OS into the ground.
2. And as Pavan Davuluri and the entire team dedicated to fixing Windows have convinced us regular users that fixes are coming to the OS, the CEO is telling investors that more investment is coming to Windows 11.

Based on the track record and the money attached to it, there’s more reason to believe this than there was a year ago.

Some of the fundamentals Windows 11 already picked up in 2026:

• Movable taskbar, restoring top, left, and right positioning that Windows 11 removed at launch, currently testing in Insider builds
• Lower baseline RAM usage across the OS, an idle memory problem Microsoft tried and abandoned once before, back in the “20/20 project” era, before restarting the effort this year
• Memory leaks, slow startup, and File Explorer white flash bugs fixed in one of the year’s biggest under-the-hood updates
• Faster File Explorer deletion for large, fragmented files, plus a quicker Home tab
• Readable file sizes in Details view, replacing the old KB-only display with proper MB and GB units
• Decluttered Windows Search, dropping MSN tiles, trivia, and ads in favor of faster, more relevant local results
• Copilot pulled out of apps where it didn’t belong, including a full removal from Snipping Tool and a rebrand to “Writing Tools” in Notepad
• A modernized Properties dialog, rebuilt in WinUI with dark mode, replacing a design that dated back to Windows 95

There’s a lot more than what fits here. Windows Latest broke down all 18 confirmed fixes coming to Windows 11 in 2026 back in April, covering everything from WSL performance to Windows Hello reliability, and it’s worth a full read.

When regular users will see these changes

Most of what’s listed above is still limited to Windows Insiders or has only recently reached stable PCs through optional updates. Microsoft’s pattern has been to test fundamental changes in the Experimental channel for a few weeks before folding them into a monthly Patch Tuesday or optional update.

But, as Nadella mentioned more investment, we’ll continue seeing more improvements throughout the year and well into next year as well.

Investors don’t get promises about UI polish for free; they get them because Microsoft thinks fixing Windows 11 now affects the business later, especially with Windows positioned as the front door for “secure edge AI” that Nadella mentioned in the same breath.

The post Satya Nadella confirms major quality update for Windows 11 with focus on fundamentals appeared first on Windows Latest

Read more of this story at Slashdot.

The first thing I do when Microsoft’s 10-K or 10-Q comes out is hit Ctrl-F and go waaaay down to the section called “Revenue, classified by significant product and service offerings.” It’s on Page 85 of the 10-K that came out Wednesday with its quarterly and annual results.

From my perspective, this gives the clearest view of what’s actually happening in Microsoft’s business. It groups things into categories and product names that match a real-world understanding of the company, as opposed to the mumbo jumbo you have to decode otherwise.

Microsoft reports its results in three broad segments: Productivity and Business Processes, Intelligent Cloud, More Personal Computing. Businesses like Azure, Xbox, Windows and LinkedIn all basically disappear inside them, until you dig into the filing.

Overall, for the fiscal year ended June 30, Microsoft’s revenue increased 18%, or $50.1 billion, to $331.8 billion. Here is what the 10-K table shows about the real drivers of the business.

Two business lines are driving nearly all of Microsoft’s growth.

Of the $50.1 billion in revenue that Microsoft added for the fiscal year, $31 billion came from Server products and cloud services, accounting for 62% of the company’s growth.

This category includes Azure, along with SQL Server, Windows Server, Visual Studio, GitHub and Nuance. Microsoft doesn’t detail Azure revenue in its financial statements, but CEO Satya Nadella said on the earnings call that Azure passed $100 billion in annual revenue for the first time this year.

At total revenue of $129.4 billion, this is by far Microsoft’s biggest business, accounting for nearly 40% of its annual revenue.

The second biggest growth came from Microsoft 365 Commercial, which added $14.2 billion in revenue, up 16% to $102 billion. Microsoft 365 Commercial covers the business subscriptions: Office, Teams, SharePoint, Exchange, security and compliance, and Microsoft 365 Copilot.

Taken together these two business lines produced 90% of Microsoft’s growth for the year.

They’re also where the company is monetizing AI most successfully: Azure, AI infrastructure and GitHub Copilot in server and cloud; and Microsoft 365 Copilot in Microsoft 365 Commercial.

Two of Microsoft’s longtime businesses got smaller.

• Windows and Devices revenue fell $230 million, to $17.1 billion. Once the biggest growth engine for the company as a whole, the PC operating system business has been flat for the past four years, using the categories as Microsoft now defines them.
• Xbox revenue fell $1.7 billion, to $21.8 billion. That’s the first annual decline since Microsoft completed its $69 billion Activision Blizzard acquisition. It comes as Microsoft overhauls the business, cuts jobs and takes a write-down on unspecified Xbox assets.

Other notes and observations from the table:

• LinkedIn, at $19.8 billion, now generates more revenue than Windows and Devices. It passed Windows in fiscal 2025 and extended the lead this year, growing 11% while Windows declined.
• Microsoft 365 Consumer was the fastest-growing category after server products, up 24% to $9.2 billion.
• Search advertising grew 9% to $15.2 billion, and is closing in on Windows and Devices.
• Dynamics grew 15% to $9 billion. Enterprise and partner services, the consulting business, grew 6% to $8.3 billion.

Thoughts? Let me know on LinkedIn. Here’s our coverage of the earnings.