Inside theSoftware Factory
A doctor and patient in a positive consultation in a bright clinic.

Photo: cottonbro studio on Pexels

healthtech · CA · 100-1000

Fullscript logoInside Fullscript's software factory

19% of January PRs created by Nitro, the in-house agent that lets PMs ship UX fixes and caught bugs in past incidents when run retroactively.

Fullscript at a glance

The company

SectorDigital health platform for practitioners and patients (supplements, wellness)
EmployeesNot disclosed as a discrete count
Customers100,000+ practitioners 1
RevenueNot disclosed

Fullscript is a private company; headcount and revenue are not publicly disclosed.

The engineering organisation

Engineering size180+ engineers 1
AI tooling sinceMid-2025, when Nitro development began; late October 2025 official launch 1
Tool policyNitro built in-house; Claude Code as swappable backbone 1
Agents in the SDLCBackground coding agent; automated code review; issue implementation 1
Reported adoption19% of January 2026 PRs created by Nitro; 45% of PRs voluntarily tagged for Nitro review 1
Published metricsPR creation share, review adoption rate 1

The 19% figure measures PRs created by Nitro, not lines of code or autonomous authorship. Human review and CI remain required on every change 1.

19%of January PRs created by Nitro
45%of PRs voluntarily tagged for Nitro review
PRs created by Nitro: 19%1 (Jan '26, current)

People

Nick Crum
Nick Crum Staff Software Engineer

What they set out to solve

Fullscript runs a mature Rails monolith with a React frontend. It's over a decade old, with millions of lines of code and 180+ engineers contributing regularly. That scale and history is an asset, but it also meant off-the-shelf AI tools didn't quite fit 1.

The specific barriers were a self-hosted GitLab instance where many tools are GitHub-first and integration was unavailable or limited, monolith complexity where the codebase needed execution in the right environment with the right access and drop-in solutions couldn't easily navigate the setup, a workflow mismatch where Fullscript uses Linear for issues and GitLab for code while many tools assume one platform or the other, and internal infrastructure where they wanted something that could access internal APIs, run against staging environments, and use their secrets management 1.

Leadership gave a small team a mandate: figure out if this could work. It was a gamble, pulling developers off product work to chase an idea that might not pan out. Within six months, they had something real 1.

Maturity level

L4 · AI-nativeof 5
TraditionalAI-supportedAI-assistedAI-nativeAI-autonomous

Assigned by testing published facts against fixed criteria, and capped by what the sources state.

How Fullscript's software factory works

Nitro is an agentic developer in the cloud integrated with all of Fullscript's tools. It doesn't live on laptops. It lives in the issue tracker and code review system. Assign it an issue, and it opens a pull request. Add it as a reviewer, and it leaves comments 1.

How engineers use it

  • In GitLab: Mention @nitro in any issue or PR comment.
  • In Linear: Assign Nitro to an issue or tag it in comments.

No new tool to learn. No context switching. Just work where engineers already work 1.

What it can do

Code reviews. Fullscript requires two reviewers on every PR with at least one approval to merge. That's a lot of review work across 180+ engineers. Nitro helps carry that load. Add Nitro as a reviewer and it leaves inline feedback on conventions, performance issues, and security concerns, consistent every time. Developers are voluntarily tagging Nitro on 45% of PRs 1.

Catching what humans miss. Fullscript retroactively ran Nitro Review on past pull requests that had caused production issues. Nitro identified the bugs. If they had been using Nitro on those changes, they could have prevented real problems. Not because humans are bad at reviews, but because AI doesn't get tired, doesn't skim, doesn't rush before a meeting. It applies the same attention at 11pm Friday as 9am Monday 1.

Issue implementation. Assign a Linear issue to Nitro. It reads the issue, writes code, and opens a PR. Works best for well-defined, scoped tasks 1.

Answering questions and writing tickets. Ask Nitro to dig into an issue and it'll explore the code, understand the context, and respond in the thread. From there, have it update the issue with better context or split a vague issue into smaller, well-spec'd tickets in Linear with proper details and code references 1.

Expanding who can contribute. A PM describes a visual bug or small UX issue. Nitro opens a PR ready for review. A designer requests a copy change. Working code, ready for review. An operations lead fixes an unintuitive aspect of an admin tool that's been bugging them for months 1.

Addressing feedback without context switching. Put up a PR, move on to the next task, let feedback accumulate. When ready to address it, leave a comment, "@nitro address the feedback," and it pushes the fixes with full context on the discussion. No branch switching, no context thrashing 1.

Under the hood

Each request spins up a fresh environment with a clean clone and no state leakage between runs. Claude Code powers Nitro as the backbone, though this is swappable for Codex, Gemini, OpenCode, or others; Claude has been the best fit so far. GitLab and Linear events trigger Nitro automatically via webhooks, and responses post back to the source. Fullscript already had facilities for developers to stand up testing environments on the fly, and they gave that ability to Nitro too 1.

Fig. 1
Linear GitLab Nitro webhook trigger Fresh env clean clone, Claude Code, Nova skills CI + E2E tests must pass Pull request 2 human reviews Every Nitro PR requires two human reviewers with at least one approval before merge [1]
How Nitro runs from a Linear issue or GitLab mention to a merged pull request, as described in the Nitro post [1]. Original diagram, not a reproduction.

What works and what doesn't

The quality bar doesn't change: human reviewer on every PR, developer approval to merge, CI and E2E tests have to pass. Nitro's output goes through the same process as anyone else's code 1.

Where Nitro shines: well-defined, scoped tasks. Fixing flaky specs, small UX changes, resolving N+1 queries, bug fixes with stack traces, feature flag cleanup, scoped tasks within larger features, prototyping from designs 1.

Where it struggles: ambiguous tasks (vague requirements produce vague output), deep architectural work (doesn't understand system-wide tradeoffs well), large context needs (changes touching many files can exceed useful context) 1.

Operating Fullscript's software factory: teams, roles, and skills

Nova is the shared skills library that teaches coding agents Fullscript's standards. It's automatically added for users in their environment. EKG is the internally developed MCP gateway with role-based access and PII/PHI redaction built in 5.

The pattern that emerged from large refactoring work: directors started assigning Linear tickets directly to Nitro. Instead of treating it like a second-class tool, teams started treating it like a real engineer: Nitro picks up the ticket, performs the migration, engineers review and test. The bottleneck stopped being "who has time to migrate 50+ modals" and became "how quickly can we perform code reviews and test the code" 2.

This shifts engineers higher up the stack, toward setup, review, and higher-value work. The valuable work is no longer manually updating the 50th modal implementation. It becomes designing better migration strategies, defining architectural patterns, writing high-quality skills, reviewing complex edge cases, and testing the implementation 2.

Implementation journey

  1. Mid-2025
    Nitro development begins. Leadership gives a small team a mandate to figure out if building an in-house agent could work 1.
  2. Late October 2025
    Nitro officially launches 1.
  3. January 2026
    19% of PRs created by Nitro; 45% of PRs voluntarily tagged for Nitro review 1.
  4. February 2026
    Post published. CEO has shipped three changes via Nitro, including a bug fix and a new mobile app feature 1.

Measuring Fullscript's software factory

The headline figures are PR creation share and review adoption: 19% of January 2026 PRs created by Nitro, and 45% of PRs voluntarily tagged for Nitro review 1.

No stated percentage of AI-authored code appears in the sources. The 19% figure measures PRs created, not lines or autonomous authorship. Human review and CI remain required on every change 1.

Lessons learned

Early on, Nitro was used to fix some N+1 queries. It didn't have a full understanding of some nuances in the setup, how certain patterns could surface N+1s in ways that weren't obvious. The fix it proposed looked reasonable, passed human review, and shipped. Then it caused 500s in production. They reverted it 1.

That failure clarified something: Nitro can only be as good as the context it's given. Conventions that lived in people's heads? Nitro didn't know them. And honestly, neither did some developers at the time 1.

To make Nitro effective, they had to document things they'd never written down: conventions, patterns, the nuances that caused that N+1 incident. This documentation helps new developers just as much as it helps Nitro. Teaching an agent exposed gaps in how they taught humans. They are writing more documentation than ever before, partly due to time saved by these tools and the incentive to make them better 1.

What's next for Fullscript's software factory

Three directions are described: faster and more responsive by reducing environment spin-up time and less waiting, mid-task interaction where the current fire-and-forget model becomes back-and-forth with follow-up, course correction, and iteration, and more platform integrations including Slack triggers and notifications, a CLI, and a front end for more ways to trigger and interact with Nitro. The goal is more like a teammate you can ping, less like a batch job you submit 1.

Patterns in this factory

Gaps in the record (5)
  • No company headcount or revenue disclosed; only that there are 180+ engineers.
  • No cost or spend figures disclosed for Nitro usage.
  • The 19% figure measures PRs created, not a claim about lines of code or autonomous authorship.
  • The production incident (N+1 fix causing 500s) is described but no frequency or total incident count is provided.
  • No stated definition of what counts as a "task" or the scope of Nitro's review feedback.
Sources (5)
1
So We Built Our Own Agentic Developer…and then the CEO shipped a feature
Nick Crum · Fullscript engineering · 2026-02-03
2
So You Want to Refactor Code with an Agentic Developer
Fullscript engineering · Fullscript engineering
3
Using Nitro for Terraform deprecations
Fullscript engineering · Fullscript engineering
4
How PMs Use Nitro for Small Code Changes
Fullscript product management · Fullscript product management
5
Is Your IT Team Ready to Build with AI?
Fullscript engineering · Fullscript engineering