Critique v4.1: Your Merge Verdict, Where Your Team Already Works

The problem was never the review. It was the extra tab.

If you have been using Critique for a while, you already know the feeling when it clicks: finally, one place that remembers the full story on a change—not just the diff, but whether policy agreed, what evidence was required, and whether merge was actually allowed.

That relief came with a quiet tax. Someone had to open Critique to get the answer. Meanwhile the real conversation was happening somewhere else: the Linear ticket, the Slack thread, the on-call channel, the agent run in Cursor at 2 a.m. The verdict was right. It just was not present where the work was happening.

v4.1 is our answer to that gap. We are not asking your org to “adopt another tool.” We are putting the same merge verdict into the tools your org already adopted years ago.

What we shipped (and what we did not try to become)

Critique is not trying to replace Slack, Linear, or GitHub. You should keep those. We want to be the layer those tools can trust—the place that knows whether this change is allowed to merge, what was proven, and what production taught you last time someone shipped something similar.

That shows up in four practical ways. Most teams use more than one; you do not have to pick a religion.

Connections: five minutes, then your stack knows Critique exists

Open Settings → Connections and you will see a page built for operators, not integrators. We lead with Zapier on purpose: your company already has a Zapier footprint, and we would rather you compose the long tail there than click through five half-finished OAuth flows inside Critique.

When you do connect Linear natively, the flow is deliberately boring in a good way: paste your key, test it, toggle which surfaces can use it, done. Same idea for Slack—a bot token or webhook when you want Critique to post with a confirmation step so nothing embarrassing lands in #general by accident.

Why bother? Because copy-paste is expensive at scale. The fifth time someone dumps a Linear ticket into chat, the product should already know that ticket exists. The third time Sentry fires during a deploy, Critique should already be looking for the passport that matches that release—not waiting for a heroic engineer to connect the dots manually.

A dashboard that answers “what needs me today?”

If the only reason you opened Critique was “see the latest PR,” v4.1 will feel different the second you land on Overview. You still get the numbers that matter—open passports, blocks, live evidence runs—but the page is organized around judgment, not configuration.

You will see a connection health strip for the tools that feed your reality: GitHub, Linear, Sentry, Jira, Vercel. You will see a passport queue preview—what is waiting for a human. You will see a timeline that mixes incidents, gate decisions, merge policy, and delivery health so you are not reconstructing the story from five browser tabs.

When Linear is connected, you also get a workspace panel: assigned issues beside recent incidents that already touched a passport. That is the product thesis in UI form—home should feel like a morning briefing, not a list of installs you forgot to finish.

Critique Chat stops pretending your tracker does not exist

Disconnected chat is just another generic assistant with repo access. Connected chat is an operator console—allowed to be opinionated because it sits on governance data, not only files.

With Linear connected, you can search issues and roadmap inside the same thread where you are asking about a failing test or a policy exception. “ENG-442” can be tied to the repository you already selected and the passport you are trying to unblock. Less tab switching. Fewer “wait, which ticket was that?” moments in standup.

Your coding assistant should read the verdict—not guess from comments

Agents made shipping faster. They did not make “is this safe to merge?” easier. When Cursor or Claude asks what is blocking a PR, the answer should not be vibes from a thread. It should be the same verdict your merge policy already produced—risk band, evidence, and what still fails.

v4.1 lets you connect your assistant to Critique in a few clicks: create a key, point your IDE at Critique, and your agent can see open passports, read a review run, or queue a new review on the commit you specify. You stay in the editor. Critique stays the system of record at the merge boundary.

We are not asking you to fire your agent. We are giving it read access to the judgment layer comment bots never had.

For platform teams: embed the verdict where leadership already looks

Many companies already built an internal “release health” or “change radar” view. Before v4.1, wiring Critique into that view meant brittle exports or scraping. Now you can pull the same passport and review data the dashboard uses into your portal—with scoped keys your security team can reason about.

That is how Critique shows up in the ecosystem without forcing every engineer to learn a new UI. Your platform team embeds status. Your runbook checks completion. Your security dashboard highlights high-risk open changes. The merge boundary becomes visible where decisions already get made.

Who feels the win first?

The story after v4

v4 answered what must be true before merge. v4.1 answers where that truth should appear so your organization actually behaves as if merge policy matters—not only on the day someone remembers to open Critique.

If you are already on passports, take fifteen minutes this week: connect Linear or Zapier, mint a key for your assistant, skim the new Overview once. The next time a PR opens after hours, you will want the verdict waiting in the tools your team already trusts—not locked in a tab they will open tomorrow. For what shipped next, read the Critique v5.0.0 beta essay — marketplace, merge policy compiler, warm Coding Agent API sessions, and repo-first dashboard.