Read the Licences Before the Lawyer Does

Last week I wrote site copy that says, of a licence opinion, "no audit of the code it covers." Then a follow-up thought: I had never produced such an inventory myself. I was selling the check without ever having done it. So I built the tool that does, and ran it on my own codebase.

The tool is a Claude Code skill called oss-licence-audit, open-sourced in Inkstone. It reads a repo's manifests and installed packages, classifies every licence, and prints an inventory with a flag list and a lawyer handoff. Deterministic script, no network calls, safe on private repos. The guinea pig was Ridgeline, the food-costing system I built for Outward Bound Hong Kong. If the skill was going to embarrass me, better there than on a client's codebase.

What 383 packages look like

Ridgeline is a Next.js app: 17 production dependencies, 12 dev, 354 transitive. The headline is boring. 378 permissive (MIT, Apache-2.0, ISC, BSD), zero strong copyleft, zero network copyleft. No GPL is going to eat the codebase.

The interesting part is the five MEDIUMs. Two copies of libvips, LGPL-3.0, arriving through sharp through Next.js image optimization. Three copies of lightningcss, MPL-2.0, arriving through Tailwind. All transitive, all build-adjacent, all the kind of thing nobody chose and everybody ships. libvips is a native library: if it lands in a server bundle or container image, the LGPL source-offer and notice duties attach to the component itself. Probably fine, worth the one-line question before it ships somewhere new. That question is the product.

The other flag was hygiene, and it was mine to fix: no NOTICE file anywhere in the repo. Every permissive licence still wants attribution in the shipped product. Cheapest fix in the report.

The run caught two skill bugs

This is the part the marketing version would skip. The first run flagged four packages as "needs review": chownr, minipass, tar, yallist. I opened them up expecting something exotic. All four were BlueOak-1.0.0, an ordinary permissive licence my classifier didn't know. One-line fix, and the classifier is better for every future run because a real repo taught it something.

The second bug was worse. The first version of the script only flagged weak copyleft in direct production dependencies, so the five transitive flags above printed silently in the table with no flag at all. A scanner that sees LGPL and says nothing is the failure mode the skill exists to prevent. Now transitive weak copyleft gets a MEDIUM that says "confirm whether it ships. Server bundles and container images count." The skill's own rule did its job: gaps stated out loud, not silently accepted. (It is one of two hard rules in the SKILL.md. The other one is "inventory, never opinion.")

Copyleft, plainly

Open source is free of charge but not unconditional. Nearly every commercial codebase is mostly open source by weight. The licences sort into four buckets.

Permissive (MIT, Apache, BSD): do what you like, but ship the attribution. Weak copyleft (LGPL, MPL): the component's own source stays open and the notices stay attached; how you link it changes the answer. Strong copyleft (GPL): if you distribute a combined work, the combined work's source goes with it. Network copyleft (AGPL, plus the source-available family like SSPL and Elastic) closes the SaaS gap. Users touching the software over a network trigger disclosure even when nothing is "distributed."

The last distinction is the one that bites. "We only run it on our servers" defeats GPL and does nothing against AGPL. On-prem delivery, mobile apps, customer-facing containers, and OEM deals all count as distribution. The trigger table fits on an index card; the argument about whether your architecture forms a "combined work" is where lawyers earn their fees.¹

What the law firms do, and where I fit

Firms like Deacons do this as IP audits and M&A diligence. Someone technical produces the inventory (a software bill of materials, built with tools like Black Duck or FOSSA). The lawyers map each component to its obligations given how the product is built and sold. Their IP partner published a piece this year making the "free software is not really free" point. Mainstream practice, not exotic.

The skill sits underneath that workflow. The opinion is only as good as the inventory it rests on, and retroactive scans routinely miss vendored code, transitive dependencies nobody chose, and bundled frontend libraries. My engagement, the Read-back, is the technical half: produce the inventory, ask the sharp questions, hand counsel something solid to opine on. Running it on Ridgeline first means I can show the output instead of describing it.

Two things the skill refuses to do, by design. It never concludes whether a use is compliant. That sentence belongs to a lawyer, and an open-source tool that emits legal conclusions unsupervised is a liability machine. And every report ends with what the scan cannot see: vendored code with no package entry, bundled JS, containers, dual-licensing, the combined-work question. Named gaps are expertise. Silent gaps are negligence.

What's next

v1 is npm-only, which covers my repos and a large fraction of everyone else's. Python, Go, Rust, and container layers are reported as present-but-unscanned, which is honest and also the roadmap. The NOTICE file for Ridgeline is a ten-minute job I have now assigned to myself in public, which is one way to make sure it happens.

The skill is installable from the Inkstone marketplace plugin. Run it on something you ship. If the output is boring, good. Boring is the goal. If it isn't, you now know which question to ask, and of whom.

Footnotes

1. The AGPL-in-SaaS question deserves its own post. Short version: if any dependency in your backend says AGPL and you serve users over the network, stop reading blog posts and call your lawyer. ↩

This post was written with the assistance of Claude (Anthropic). The author provided editorial direction, project context, and fact-checked all claims. The AI assisted with drafting and research.