Plus One for Developers

This is the developer cut of a bigger argument.

We wrote about Plus One as a coordination layer that takes the call when you can't — across sales, support, recruiting, every role in a company. The version of that story that matters most to us is the one for engineers, because the cost of an interrupted developer is the highest, least-visible cost in modern software. If you haven't seen the broader thesis, the launch post is the shortest read.

This post is about what Plus One actually does for the person writing the code.

Sorry, no quick calls... talk to my EA.

That's the DM every developer has wanted to send to anyone pinging them while they're locked in.

Because "quick call" is the most expensive lie in software.

It looks like 15 minutes on a calendar. It actually costs the 90 minutes of context you'd loaded into your head — and the hour afterwards trying to claw it back. That's the interruption tax, and every developer pays it daily.

So engineers do one of two things:

• Sit in the meeting "just in case" and ship nothing that day.
• Skip it — and the work stalls because no one could answer live.

Neither is a real choice. Both are losses. And notetakers don't fix this. The meeting still happened. You were still in it. You still lost the architecture you had loaded in your head.

We built Plus One to change the unit of work.

The shape of the problem

If you've shipped production software, you know the feeling. You're three layers deep into a refactor. The whole module graph is in your head. You can see the type that needs to change, the four call sites it'll cascade through, and the one edge case the existing tests don't cover.

Then the ping lands.

"Hey — quick question, got 15 min? PM wants to walk through the export feature scope before standup."

There is no version of this where you keep what's in your head. You either say yes and lose the next four hours, or you say no and the export feature sits on the PM's list for another two days. The cost shows up nowhere on the calendar. It shows up in the velocity chart, in the burnout survey, in the staff engineer who quietly turns off Slack on Wednesdays.

The problem is not the PM. The problem is not the question. The problem is that the only interface for transferring context between two humans is still a synchronous call — and one of those two humans needed an hour of warm-up to be on it.

What Plus One actually does on the call

A Plus One is not a notetaker. It is not a transcription bot. It is not a summarizer that emails you a wall of text after the meeting.

It is the call itself.

Your PM clicks the link. Your designer hops on. Your customer joins. They get a real video conversation — with your Plus One, not you. The AI:

• Sees the screen share — the Figma frame, the dashboard, the Looker query, the failing build
• Listens to what they're actually asking — not just the literal words, but the underlying intent
• Asks the follow-ups a good EA would ask — "do you want this gated behind a feature flag?", "is this for the customer who churned last month, or a new ask?", "who's the user — admin, end-user, or both?"
• Captures the constraints they mention in passing — the launch date they slipped in, the analytics event they want fired, the edge case they're worried about
• Refuses to commit to anything that needs your call. It says, "I'll get this in front of the developer with everything we just discussed."

The person on the other end does not get blown off. They get heard, in full, by something that understands what they're trying to do. The work moves forward. The decision still comes from you.

What lands in your Slack when the call ends

This is the part that matters for developers. Because the brief is not for a human reader. It's for you, and it's for your coding agent.

When the call ends, Plus One drops four things into your Slack:

• Notes — the key points in the structure you read fastest, not a meeting transcript
• The recording — in case you want to scrub a specific moment
• The transcript — full text, searchable, timestamped
• A prompt — ready to paste straight into Claude Code

That last one is the unlock.

The prompt is not "here's what they said." It's a structured spec — the feature, the constraints, the edge cases, the rollout preference, the success criteria, the questions still open for you to decide. Formatted the way an agent eats it, not the way a human reads it.

You paste it into Claude Code, scope what you want it to actually do, and the work moves on the same context the meeting just produced. No re-explaining. No re-reading the transcript. No "wait, what did they say about pagination again?"

The meeting and the implementation are now one continuous handoff, not two disconnected events with you in the middle paying the tax.

Why this matters more for developers than for anyone else

Every role has interruption cost. For developers, the cost is non-linear.

A salesperson interrupted mid-call loses a minute of script. A designer interrupted mid-mockup loses a frame. A developer interrupted mid-flow loses the entire mental model of the system they were working on — every type, every call site, every invariant, every test they were planning. Getting it back takes 60-90 minutes if it comes back at all.

This is not a soft cost. This is the reason engineering velocity dies in growing companies. Not because the engineers got worse. Not because the codebase got bigger. Because the number of people who can ping a senior engineer scales linearly with headcount, and the flow state required to ship hard things does not.

Plus One is the first tool that actually changes this equation. Not by adding another notification setting. Not by adding another do-not-disturb mode. By taking the call.

The teammates you stay async with

The people who ping you — they're not your enemies. They are doing their job. The PM needs the scope. The designer needs the constraint. The customer needs the answer. The new hire needs the unblock.

The problem is that the medium of their question is a synchronous call, and you are the bottleneck on that medium.

When you have a Plus One:

• The PM gets the call. Your Plus One walks through the scope, captures the constraints, and hands you a one-line: "PM wants user-level export. Confirmed it should be CSV, behind a feature flag, scoped to admins. Ok to start?"
• The designer gets the call. Your Plus One looks at the Figma, asks about empty states and loading states, and hands you: "Designer needs the dashboard hooked up. Empty state covered. Loading state TBD — needs your call between skeleton and spinner."
• The customer gets the call. Your Plus One hears the actual bug, captures the repro, and hands you: "Customer hit a 500 on POST /orders when address.line2 is missing. Repro attached. Logs attached. Want me to file the ticket or are you on it?"
• The new hire gets the call. Your Plus One walks them through the architecture from the docs, captures the questions it couldn't answer, and hands you: "New hire asked three things I couldn't answer — all about the auth refresh flow. Here they are."

In every case, the loop closes for them in minutes. You stay in flow. The decision comes back to you when it actually needs you, and not a moment before.

What "in flow" really means for an engineer with Plus One

Being in flow is not just "do not disturb." Do-not-disturb is a wall. Plus One is a filter.

The wall blocks the urgent thing along with the noise. The filter lets the urgent thing through — already triaged, already understood, already framed for you to make the call in 60 seconds — and absorbs the noise.

The difference between those two over a quarter is the difference between a developer who shipped the migration and a developer who almost shipped the migration but kept getting pulled into other people's questions.

Plus One keeps you async with teammates while you stay sync with Claude. That's the new shape of the engineer's day. One synchronous loop — you and the agent, in the code. Every other loop is async, intermediated, and arrives on your desk pre-chewed.

Try it

This is not a feature on the roadmap. It's live today.

Give your Plus One the URL of your project, the docs you point new joiners at, and the boundaries of what it can answer for you. Your Plus One lives at a permanent address: waterr.ai/your-username. Drop that link in your Slack bio, your email signature, your calendar URL - anyone you allow can open it and get a live 1:1 with your Plus One, anytime. The next "quick call" that lands - let your Plus One take it. And because the link never expires, the PM who talked to it on Tuesday comes back Thursday with the follow-up without ever booking you.

You get the next two hours back. They get a real conversation. The work moves either way.

That's the deal Plus One is making with developers. Stop paying the interruption tax.

Read next: Async Video Calls — The Default Coordination Layer for the full thesis on how this shape of work scales beyond engineering, and Introducing Plus One for the short version of why we built it in the first place.