In this article
If you run an engineering team in 2026, you probably have a Shipmate of your own. Ours began as an afternoon experiment at our Mid-Year Kickoff in July. Today it’s a plugin on every Jellyfish engineer’s machine that can take a ticket all the way to a review-ready PR, and the engineers who use it most are merging 32% more pull requests than before, about 3x the gain of everyone else.
Over five years at Jellyfish, I’ve led a lot of initiatives from zero to one, and I wanted to build something that helped all of us move faster. Once Shipmate caught on, everyone started asking the same question: is it actually making us faster?
This is the story of how Shipmate started, the principles that shaped it, how we used Jellyfish to measure its impact, and what we learned along the way.
How it started
How it started
This July, Jellyfish held its first-ever Mid-Year Kickoff: two days where the whole company heard from guest speakers, leadership, and peers about emerging trends and product direction. A big part of it was about using AI (as it probably was for most companies this year), and one of our guest speakers, Dan “Caddy” Caddigan of 3Play Media, gave a great talk on how 3Play was putting AI to work, built around the idea of a “super skill.”
A super skill isn’t one skill that solves one workflow. It’s an entire persona: a suite of skills that together act almost like their own entity, figuring out what to do, choosing the best way to do it, and then doing it.
I had already experimented with skills and hadn’t found them very useful on their own. But the idea of a persona changed that. LLMs are really interpreters. So what if you gave one everything it needed to interpret the work, and then let it do the work?
I found the idea so compelling that I started coding that afternoon. But first, I needed a name.
3Play has several of these super skills. Night Shift ships code end to end overnight. Project Breakdown, as you might guess, breaks down projects. And my favorite, Bette Midler, is in charge of meddling with the bets: helping choose which projects to work on. I’m a sucker for a good pun, I loved the idea of a name that sounded like a person, and I wanted my first super skill to ship code. So I named it Shipman (pronounced “ship-min”).
After some debate, Shipman became Shipmate, so we wouldn’t be assigning a gender to our new near-sentient robot overlord. The new name also unlocked a whole fleet of boat emojis, and somewhere along the way, the project became pirate-themed. 🚢 🏴☠️
The proof of concept
The proof of concept
The first version took me about ten days. I didn’t try to build the whole persona at once. I built it one job at a time.
First, the most annoying job. The very first skill was shipmate-fix-pr, and all it did was resolve Cursor Bugbot comments. We had recently enabled Bugbot for the entire org, and everyone was wading through its findings. For every comment, someone had to read it, decide whether it was real, and reply. It was tedium for engineers. But the perfect kind of work for Claude to handle.
One skill became three. Once we could clean up a PR, it made sense to cover the steps before it. shipmate-build implemented a ticket, and shipmate-draft-pr wrote the pull request.
Three skills became a playbook. I wrapped them in a single shipmate skill that knew what order to run them in. For the first time, you could hand over a ticket and get back a PR. It was the first real version of the super skill.
It’s worth pointing out, none of this was new work: implementing a ticket, writing a pull request, answering review comments. Engineers were already doing every one of these steps, either by hand or by prompting Claude one step at a time. Shipmate just turned that collective know-how into a single easy-to-run playbook.
Grounding it in principles
Grounding it in principles
Up to this point, the proof of concept lived only in our core monorepo, and many of our fellow engineers still couldn’t use it. That’s when I joined forces with our AI Champions group, a team of engineers responsible for championing AI-powered development across the company. Over the next ten weeks, I worked with Mika Sade and Adam Dobkin to turn Shipmate from a personal experiment into a plugin for everyone.
But before adding anything new, we agreed on three principles.
An environment principle: stay universal. Shipmate doesn’t hard-code how an engineer works: which model to use, whether to create git worktrees, or how hands-on to be. Changing the model changes the quality of the output. Worktrees change someone’s file system. And some people want to review every step while others want a PR at the end. Any one of those is a dealbreaker for someone.
So Shipmate sorts every choice into one of two buckets:
| Bucket | What goes in |
| Built in (same for everyone) | The most broadly useful part of each job, from sequencing the work to drafting the PR. As shareable as possible. |
| Your call (left to the engineer) | Anything specific to how someone works, like which model to use, whether to create git worktrees, or how hands-on to be. |
A design principle: teach it how Jellyfish works. Shipmate is a companion for our software development lifecycle, not a coding coach. Making Claude a better coder isn’t our job; the model does that. Most of Shipmate should be Jellyfish practices encoded into skills: the things a model won’t learn on its own.
The test is simple: if we hired a new engineer tomorrow, what would we teach them in their first few weeks? That’s what belongs in Shipmate.
| Bucket | What goes in |
| Encode (built to last) | How Jellyfish works: how we sequence the work, the tools we use, and the templates we prefer. |
| Keep thin (temporary) | Baseline guidance for comments, tests, and prose, re-checked often and retired as newer models stop needing it. |
| Leave out (the model’s job) | General coding skill. The model already handles that, and it keeps getting better. |
An architectural principle: persona, playbooks, leaves. The goal is a super skill that’s as versatile as possible. This is what it means to let the LLM be the interpreter: instead of scripting every path, give the model well-defined pieces and let it decide how to put them together.
So Shipmate is built in three layers:
| Layer | What it does |
| Persona | The single entry point. Say “Shipmate,” and it reads what you have and what you want, then routes to the right playbook or leaf skill. |
| Playbooks | Curated workflows. Each runs a predefined sequence of skills for a common task, such as taking an issue to a PR or planning a project. |
| Leaf skills | Composable atomic actions. Each does one job, such as drafting a PR, fixing CI, or writing tests, on its own or within a playbook. |
When a request fits a playbook, like taking a ticket to a PR, Shipmate runs the playbook. When it doesn’t, Shipmate skips the playbooks and picks just the leaf skills that make sense, like only drafting the PR when an engineer wants to write artisanal, hand-crafted code.
This structure also makes Shipmate easy to extend. A new capability is usually one new leaf skill, plus a line in whichever playbook needs it.
Building it out
Building it out
With the principles in place, we started building. Over those ten weeks, Shipmate grew in three broad strokes:
Everyone gets it. We moved Shipmate into a plugin, used managed configuration to put it on every engineer’s machine automatically, and added a setup playbook that installs and connects whatever it needs, so a new user’s first command just works.
A more robust pipeline. The proof-of-concept pipeline grew into a full issue-to-pr playbook. It runs build-branch to implement, self-review, and test the change, drafts the PR, then runs fix-pr to work through AI review comments, CI failures, and human feedback.
Beyond the PR. New playbooks cover both ends of the lifecycle. The plan-work playbook turns a PRD into a Linear project with milestones, a technical plan, and issues. The triage-bug playbook takes a bug report from Slack, files it, and diagnoses the root cause.
Ten weeks later, Shipmate looked like this:
shipmate(persona)issue-to-pr(playbook)build-branch(playbook):implement-issue,review-code,write-testsdraft-prfix-pr(playbook):address-agent-comments,address-reviewer-comments,fix-ci
plan-work(playbook):create-project,create-issue,write-tech-plan,write-rfc,write-adrtriage-bug(playbook):read-slack,create-bug-issue,diagnose-bugsetup(playbook):check-setupfix-setup(playbook):setup-git,setup-github,setup-jq,setup-linear,setup-circleci
What Shipmate does today
What Shipmate does today
Now any engineer can say “Shipmate, do this ticket,” and it takes it from there:
- Reads the Linear issue and assigns it to them
- Implements the change and writes the tests
- Reviews its own branch for bugs and fixes what it finds
- Drafts the pull request in plain language
- Responds to the AI review comments, then to the human ones
- Fixes CI until it’s green
Engineers went from being flooded with Linear triage tickets to having Shipmate resolve them end to end. Their time moved from writing PR descriptions and reading Bugbot’s ramblings to solving higher-level, human-shaped problems. Shipmate took on the busywork, and engineers got their focus back.
Today, about half of our engineers use Shipmate, and it feels faster. The next question was whether it actually is.
Finding evidence it worked
Finding evidence it worked
Feedback in Slack was telling us Shipmate was useful, but not whether it was actually helping us ship more features. To find out, we broke it down into three questions.
First, when did people start using it? In Jellyfish, we used Custom Metrics to create a metric called Shipmate Invocations Per Person, which counts every Claude skill invocation event for Shipmate, across both the pre-plugin and plugin versions, grouped per person per week.

Average Shipmate invocations per engineer, by week. The shaded band marks the after window.
Once we could see usage, a clear pattern stood out. After the proof of concept, usage rose steadily, and by mid-August it crossed an average of 10 invocations per person per week. It rose again once we released the plugin, climbing past 20 by late September.
For our analysis, we used that mid-August inflection as the dividing line between “before” and “after.” This gave us a solid 8-week window once Shipmate was reaching steady usage. For the before window, we reached back 20 weeks for a reliable baseline.
Next, who is using it most? We wanted to compare engineers by how much they used Shipmate. The easy trap is to compare users with non-users. But that would pit two different groups of engineers against each other, which can easily lead to confounded conclusions, especially if our top performers were the first to adopt. So instead, we asked whether the same people got faster after they started. To do this, we used Cohorts to group engineers by their Shipmate Invocations during the after window, so we could see how usage affected gains:
- Light users (17 engineers): fewer than 5 invocations/week (~3/week on average)
- Active users (15 engineers): 5 or more invocations/week (~21/week on average)
- Top users: the five heaviest users, a subset of Active (~36/week on average)
Finally, is it making anyone faster? We picked two delivery metrics we already trusted, Pull Requests Merged and Issues Resolved, and used Dashboards to chart these metrics before and after the split for each cohort of engineers. Since the Shipmate metric sat right next to that delivery data, it was easy to line up each engineer’s usage against their own output.
Here’s what the dashboard showed:
| Cohort | Runs / week | Issues / person / week | PRs / person / week |
| Light (17) | ~3 | 3.7 → 4.1 (+11%) | 3.4 → 3.7 (+10%) |
| Active (15) | ~21 | 5.3 → 6.7 (+25%) | 4.7 → 6.2 (+32%) |
| Top 5 | ~36 | 6.6 → 8.7 (+32%) | 6.0 → 7.9 (+32%) |
Median per engineer, per week, in each cohort. Top 5 is a subset of Active.
What we noticed first was that everyone got faster over those weeks, including the engineers who barely used Shipmate. That made the Light cohort our baseline.
Against the baseline, the difference is clear. Active users resolved 25% more issues, over 2x the gain of Light users. And Top users did even better, resolving 32% more, nearly 3x the gain of Light users. That’s two more issues resolved per person per week.
PRs tell a similar story, but the gains don’t scale forever. Both Active and Top users merged 32% more PRs, over 3x the gain of Light users. This matches what Jellyfish Research sees across the industry: moving people from light to moderate use pays off more than pushing heavy users even higher.
This is fantastic signal. But we hold these results loosely. The cohorts are small, Shipmate is young, and engineers who had a busy quarter may simply have had more chances to use it. But the direction is consistent across every cohort and both metrics: the more someone used Shipmate, the more their output grew.
Lessons from the voyage
Lessons from the voyage
These findings gave us the confidence to keep sailing in this direction, but there’s still a lot more exploring to do. We keep iterating on Shipmate with the team, and each new playbook teaches us something about how we actually build. Proving the impact with Jellyfish tells us we’re on the right track and gives us the evidence we need to widen adoption across the company. We’re bullish that as more engineers come aboard, the gains will grow with them, and we’ll keep measuring to find out.
We also learned a lot along the way. So if you’re looking to build your own version of Shipmate (with your own punny name), here’s what I’ll leave you with:
- Start simple and grow from there. Fix the most painful step in your process first. Once the value is obvious, build out.
- Bring the team along as you build. You’re building a system that has to be adoptable, not just valuable. Listen to feedback and act on it.
- Encode how your company builds, not what it builds. Teach it the same things you’d teach a new hire. Let your agent handle the annoying process stuff.
- Build guidelines, not guardrails. The agent’s job is to interpret what to do, with the guidance to do it well. Don’t force a one-size-fits-all workflow.
- Make adoption easy. Install and update the tool automatically, and remove any red tape. When you see a chance for someone to use it, tell them.
- Measure, measure, measure. Start with adoption, then impact. Get people using it, find what it makes faster and what it doesn’t, then optimize.
Special thanks to Mika Sade and Adam Dobkin, who built Shipmate alongside me in the AI Champions group, and to Dan “Caddy” Caddigan of 3Play Media, whose kickoff talk started it all.
Data sourced from Jellyfish Engineering Intelligence. Before window: March 30 to August 16, 2026. After window: August 17 to October 11, 2026. Cohorts based on Shipmate invocations during the after window. Figures are each cohort’s median per engineer, per week.
About the author
Nathan Klingensmith is a Senior Software Engineer at Jellyfish, where he has spent five years leading zero-to-one initiatives. He is a member of the AI Champions group and built Shipmate.