Labelling AI use in your own work: what 0rwx measures and what it leaves out

The 0rwx framework, by Tris Oaten of the No Boilerplate YouTube channel, labels a piece of work by how much AI was involved, in four levels borrowed from unix permissions.¹ This page applies it to my own repos, which a coding agent mostly writes, and lists what its single axis cannot express. It is for anyone who builds with an agent and wants a disclosure that says more than “AI made”.

Provenance. Commit counts were measured on 2026-11-08 over the window 2026-10-20 to 2026-11-08, the span covered by the harness’s git audit log (Running agent git commands without per-command approval prompts). Founding conversations come from the cross-client session store described in A cross-client memory store for coding agents, which holds pi, Claude Code, opencode and claude.ai chats back to 2024. The founding asks were checked against the stored messages by session and message number before publishing and are paraphrased here. The origination verdicts are mine and are judgments, not measurements.

TL;DR:

0rwx grades one thing: “your ability to scrutinise the generated work”. By that test nearly everything here is AI:X, “YOU can no longer read your work”. 2,307 of 2,857 commits in the window (81%) were made by the agent, and I do not read most diffs line by line.
The founding conversations of 16 projects show I set the goal, the constraints and most of the architecture, including decisions that overruled the agent. One project, a word game, started from a design the agent proposed and I picked. 0rwx has no field for any of this.
0rwx treats reading as the only form of scrutiny. Here the checks are tests, CI, sensor-gated loops, build diffs before deploy, and using the result. 31 of the 69 repos have no test files, most of the deployment repos among them.
Patent and copyright tests already separate conception from production, and CRediT separates Conceptualization from writing. KDP classifies the other way: an idea from AI with text written by you is “AI-assisted”, text from AI that you edited heavily is “AI-generated”.
A label with one value per axis (idea, design, knowledge, build, check, stakes) describes this work. A single letter does not.

The axes a label could record

Idea: who identified the problem and the goal.
Design: who chose the architecture and the constraints.
Domain knowledge: whose expertise the design and the checks rest on. It limits what can be checked.
Build: who produced the artifact. This is the only axis 0rwx grades, through whether you can still read the result.
Check: how the result was verified.
Stakes: what fails if the result is wrong, which sets how tight the check has to be.

Scheme	Idea	Design	Knowledge	Build	Check	Stakes
0rwx	only implied by levels 0 and R	no	no	yes (as readability)	reading only	no
CRediT	yes (Conceptualization)	yes (Methodology)	no	yes (Software, Writing)	yes (Validation)	no
IBM AI Attribution	no (records who triggered each AI contribution)	no	no	yes (human vs AI share)	yes (who reviewed and approved)	no
Amazon KDP	treated as minor	no	no	yes, decides the label	no	no
USPTO inventorship	yes, decides inventorship	yes	no	explicitly not enough	no	no
USCO copyrightability	prompts not enough	selection and arrangement	no	yes, decides protection	no	no
Ghostty policy	no	no	no	disclosed	human must understand all code	no

Sources for each row are in How other schemes split the axes and the sections it links back to.

0rwx in brief

The site defines four levels, each with a phrase and a badge.¹

Level	Site definition	Phrase	Badge
AI:0	AI can’t read or write to your work	“I think”	HAND MADE
AI:R	AI has read-only permissions	“I make”	AI INSPIRED
AI:W	AI has read-write permissions	“I fix”	AI COLLABORATION
AI:X	YOU can no longer read your work	“I curate”	AI MADE

The site states the axis directly: “The difference between the 4 levels is not necessarily about what TOOL you use, but your ability to scrutinise the generated work.”¹

Oaten’s video introducing it grounds the scale in Lisanne Bainbridge’s 1983 paper “Ironies of automation”²: once automation does nearly all of the work, the operator’s skill decays and their job becomes monitoring the machine.³ From that, the video argues that at Claude Code levels of automation “people who say they read the code are lying to themselves”, and that “Claude tested it for me doesn’t cut it”. It also cites Adam Savage on tolerances: professionals know when a corner can be cut, but only if they know a corner is being cut. For anyone who rejects the levels it offers credit wording instead: an AI research assistant at R, a co-writer when AI output ends up in the work, and “if the project was mostly AI written, own it”. The project’s repository asks for “no AI please” in issues and pull requests.⁴

Where 0rwx puts this setup

Per-repo counts from the commit history, with an agent commit defined as one made within 180 s after an audited agent git commit in the same repo. Four repos whose commits ran outside the audited path, two of them upstream forks, are excluded.

Measure (2026-10-20 to 2026-11-08)	Value
Repos with commits in the window	69
Commits	2,857
Agent commits	2,307 (81%)
Repos at or above 80% agent commits	43
Repos with test files	38
Repos with CI workflows	44
Repos with a sensor-gated loop manifest	20

31 of the 69 repos have no test files. The deployment repos with the most commits are among them:

Repo	Commits	Agent	Loop manifest
router NixOS config	43	95%	no
NAS compose stacks	46	93%	yes
monitoring stack	31	94%	yes
NAS NixOS config	23	74%	no
DNS Terraform	6	83%	no

The two NixOS repos get a build diff of the activation plan before deploy. The loop manifests in the two compose repos drove a documentation split and a dashboard task, and check nothing about the running stack. Not every deployment repo lacks tests: the DNS resolver repo has 164 test files, and the edge proxy repo, which sits too deep in the directory tree for the scan and is not in the 69, has 63.

The scan covers git repos up to three directories below the home directory, so deeper nested repos are missing from every count. Commit proximity is not authorship. An agent commit can carry text I typed, a commit I made by hand can carry agent text, and Claude Code on another machine never reaches this audit log. The test counts include tests the agent wrote.

By 0rwx’s own definition the answer is AI:X across most of the corpus.

Who originated the projects

A first pass at this question sampled user prompts from the last 30 days and was wrong. Those are mid-project prompts, written after each design existed. The table below traces each project to the conversation where it started, including renamed predecessors and chats on claude.ai that predate the coding harness.

Project	Started	Founding ask (paraphrased)	Origination
APM tracker (zero-input-latency design)	2024-08-21, claude.ai	a Windows tool that shows average actions per minute, in Rust	mine
Edge reverse proxy	2024-08-08, claude.ai	review of an existing custom Caddy build	mine
Docs site (this one)	2025-05-05	first commit made by hand	mine
Film-negative inversion tool	2026-03-18, claude.ai	options for leaving a Lightroom and Negative Lab Pro workflow without a subscription	mine
Docs over SSH	2026-04-07	an SSH server for browsing documentation sets, starting with the Postgres docs	mine
Compose stack manager	2026-04-08	a lighter alternative to dockge and Portainer, which are wrappers on Docker Compose; TDD, DDD, shadcn on Astro, a Go or Rust backend	mine
Jellyfin watch-party sync	2026-05-05, claude.ai	a way for friends to watch the same thing at the same time, possibly self-built on Jellyfin	mine
Versus word game	2026-05-20	whether an open-source Wordle exists	mixed
Authoritative DNS on anycast	2026-05-23	a stack for self-hosted anycast authoritative DNS, with CoreDNS as my first guess	mine
Soulseek client for the media stack	2026-05-28	whether Soulseek beats the existing music automation, and a container for it	mine
Discord message retention tool	2026-05-28	bulk-deleting my own Discord messages, then an owned script after the agent listed third-party wipers	mine
Cross-client session store	2026-08-08	one Postgres store to query session memory from every agent client	mine
Personal knowledge graph	2026-08-13	a graph database over my old school and university documents	mine
Mouse firmware and web configurator	2026-10-23	reverse engineering a mouse’s configurator into a web driver alongside its firmware updater	mine
Windows latency CLI	2026-10-25	one CLI with flags and logging to replace a pile of tuning scripts	mine

The sixteenth project, a read-only CLI over the router, started from my question about a VyOS-style CLI for it. Its read-only boundary came from my own earlier planning notes, which the agent quoted back, and the agent coined the name after I set a naming constraint.

Decisions in those conversations that went against the agent’s recommendation:

Project	Agent proposed	I chose
Authoritative DNS	Knot first, then PowerDNS once I asked for API control	Knot, with a REST API modelled on Cloudflare’s DNS API built for it
Personal knowledge graph	an embedded Kuzu graph plus SQLite, already scaffolded	Postgres on the NAS, as I had assumed from the start
Windows latency CLI	“PowerShell module (Recommended)”, reusing the existing scripts	“Go single exe”
Discord retention tool	existing third-party wipers	an owned script, later a retention daemon with an encrypted archive

What the agent contributed across the 16: most project names, library and plumbing choices, the option menus I picked from, the written design documents and plans (drafted from my direction), and domain work I could not have done, such as decompiling the Lightroom negative-inversion plugin. The word game is the one case where the core design came from the agent. I asked for an open-source Wordle, it listed axes I had not named and proposed a roguelike versus mode, and I selected it.

A project usually starts as a question (“what are my options”, “is there a way”, “what would be a good stack”). The agent surveys, I decide, and the decisions that shape the project are mine.

What 0rwx does not record

Who conceived the work

The scale grades the artifact. A one-line “make me an app” and a project whose author set the architecture, overruled the agent’s stack and specified a zero-input-latency budget both come out as AI:X, and the video’s credit wording (“mostly AI written, own it”) assigns credit by who produced the text.

Patent law draws the line elsewhere. The USPTO’s 2024 guidance on AI-assisted inventions says “Reducing an invention to practice alone is not a significant contribution that rises to the level of inventorship”, that “Merely recognizing a problem or having a general goal or research plan to pursue does not rise to the level of conception”, and that “a significant contribution could be shown by the way the person constructs the prompt in view of a specific problem to elicit a particular solution”.⁵ Under that test the 0rwx level is beside the point. What counts is whether the human’s contribution to the solution was significant.

Copyright draws it closer to 0rwx. The US Copyright Office’s 2025 report concludes that “prompts do not alone provide sufficient control” over the output, while human selection, coordination or arrangement of AI output can be protected.⁶

Scrutiny other than reading

0rwx’s W level is “I read the code” and its X level is “you can no longer read your work”. Reading is the only check it names. The checks used here are test suites, CI, sensor-gated loops that iterate until objective checks pass (Loop or graph: a sensor-gated coding-agent loop), a build diff of the activation plan before a router or NAS deploy, guards that block unverified specifics (Guard extensions that enforce prose and process rules), and using the thing: 4 of 18 mid-project prompts in the first sample were a report of something broken in use, usually a screenshot.

The video’s warning still applies to every one of those. A test written by the agent can pass while asserting the wrong thing, and “the agent tested it” is the sentence the video rejects. Being unable to read the code and being unable to check it are different states, and a label should say which checks exist.

Whose domain knowledge it rests on

The real limit on checking is where the agent supplied expertise I lack: firmware glitching methods, a protocol’s wire format, a decompiled plugin’s maths. There I cannot judge the output even at AI:W, because reading it does not tell me whether it is right. In a domain I know, a wrong design shows in its behaviour. The closest any policy here comes is Ghostty’s “The human-in-the-loop must fully understand all code”.⁷ That asks for comprehension of the code, which a reader can have and still be wrong about the domain, and it says nothing about who typed it.

What breaks if it is wrong

The video’s tolerance argument has no slot in the labels. AI:X on a naming brainstorm and AI:X on the router configuration read the same, and several of the repos that change running systems have no tests. That is where the tolerance should be tightest.

Mixed levels inside one work

In one repo the AGENTS.md design notes, the constraints and the acceptance are mine and the code is the agent’s. In one session the level moves from R (asking how firmware glitching works) to X (a worker building the plugin). A per-project label averages this away. The unit that fits is the change or the component.

The system that produced the work

I designed the harness the agent runs in: the guards, the skills, the gates and the routing rules (The pi harness journey). The USPTO guidance counts this kind of contribution too: “a person who designs, builds, or trains an AI system in view of a specific problem to elicit a particular solution could be an inventor”.⁵ 0rwx looks only at the final artifact.

Time

Bainbridge’s argument is about skill decay over time. A label is a snapshot and says nothing about whether the labeller can still do the work by hand.

Disclosure

Grading AI use and disclosing it are separate decisions, and projects handle them separately. Ghostty requires “All AI usage in any form must be disclosed” from outside contributors and exempts its maintainers.⁷ The Linux kernel removed its Assisted-by trailer on 2026-10-09 after “The Maintainers Summit reached consensus to deprecate the Assisted-by tag”.⁸ Gentoo has forbidden “any content that has been created with the assistance of Natural Language Processing artificial intelligence tools” since 2024-04-14.⁹ The harness described here bans AI-attribution trailers in commits, so the repos disclose nothing at any level; this page is the disclosure.

How other schemes split the axes

CRediT, a contributor taxonomy journals use to credit co-authors, lists 14 roles, among them Conceptualization, Methodology, Software, Validation, and “Writing - original draft” separately from “Writing - review & editing”.¹⁰ It already separates the idea from the writing, though it was designed for human co-authors.

IBM Research’s AI Attribution Toolkit, partly inspired by CRediT, generates a statement appended to a work from three questions: “How much work did the human do relative to the AI? What were the AI’s contributions? Who reviewed and approved the final work?” Its own paper carries “This work was produced without AI assistance (AIA No AI 1.0).”¹¹ The toolkit also asks “Who initiated AI contributions?”, where AI-initiated means “AI made proactive contributions without human request, such as auto-completed suggestions or additions”.¹² That records who triggered each AI contribution, not who conceived the work. It records review, which 0rwx does not.

Amazon KDP asks authors to disclose AI-generated content and draws its line by production: content “created by an AI-based tool” is AI-generated “even if you applied substantial edits afterwards”, while “if you used an AI-based tool to brainstorm and generate ideas, but ultimately created the text or images yourself, this is also considered ‘AI-assisted’”, which needs no disclosure.¹³ That is the reverse of the USPTO test: KDP treats the idea as minor and the production as decisive.

The USPTO and USCO tests and the three project policies are quoted in the sections above.

A label with one value per axis

0rwx’s letters work as values on each axis instead of one per work:

idea:0  design:0/R  knowledge:R/X  build:X  check:test+use  stakes:low|prod

Axis	Value here	Meaning
idea	0	the problem and goal are mine
design	0, R where I picked from agent proposals	architecture and constraints are mine; the word game is R
knowledge	R in domains I know, X where the agent sourced the expertise	X marks the parts I cannot judge
build	X	the agent writes the artifact
check	test, probe, use	named checks, not reading
stakes	low or prod, per repo	how tight the check must be

This page, labelled the same way: idea 0 (the question of what 0rwx leaves out was mine), design R (the agent proposed the structure, I revised it), knowledge R/X (the agent found the legal and policy sources), build X (the agent wrote it), check: a fact-check by a second model that found three wrong claims, plus my review, which anonymised my projects. Stakes low. Under 0rwx alone it is AI:X, the level the framework’s own repository asks contributors to stay away from.

Decision guide

A quick conversation about how you work with AI: one 0rwx letter is enough, which is the use the video intends.
Readers who will rely on the artifact: give the per-axis label, and name the checks and the stakes.
A patent or copyright question: the 0rwx level is not the test. Use the USPTO conception test or the USCO selection-and-arrangement test.

Evidence

Claim	How it was checked
2,307 of 2,857 commits (81%) in 69 repos were agent commits	commit timestamps matched to the git audit log within 180 s, 2026-11-08
31 of 69 repos have no test files	file listing per repo for test file patterns, same run
Loop manifests in the two compose repos check docs and a dashboard	read both `.pi/harness.json` files
Founding asks and overrides	each checked against the stored message by session and message number, 2026-11-08; paraphrased on the page
Kuzu plus SQLite scaffold before Postgres	the knowledge graph repo’s first commit documents a Kuzu graph
0rwx definitions and the video’s arguments	site fetched and video transcribed, 2026-11-08
Legal and policy quotes	each source page fetched, 2026-11-08
Origination verdicts	my judgment from the quoted turns, not a measurement

The pi harness journey - the harness that produces the agent commits counted here.
Running agent git commands without per-command approval prompts - the git audit log the commit counts are matched against.
A cross-client memory store for coding agents - the session store the founding conversations were traced in.
Loop or graph: a sensor-gated coding-agent loop - the check that replaces reading for loop-built repos.
Guard extensions that enforce prose and process rules - including the rule that keeps AI attribution out of commits.

References

T. Oaten, “0rwx,” Namtao Productions, 0rwx.com. https://0rwx.com/ ↩ ↩² ↩³
L. Bainbridge, “Ironies of automation,” Automatica, vol. 19, no. 6, pp. 775-779, 1983. https://doi.org/10.1016/0005-1098(83)90046-8 ↩
T. Oaten, “The 0rwx Framework,” No Boilerplate, YouTube. https://www.youtube.com/watch?v=E6-1u_savRs ↩
T. Oaten, “0rwx.com,” Namtao Productions, GitHub. https://github.com/NamtaoProductions/0rwx.com/ ↩
USPTO, “Inventorship Guidance for AI-Assisted Inventions,” Federal Register, 2024. https://www.federalregister.gov/d/2024-02623 ↩ ↩²
U.S. Copyright Office, “Copyright and Artificial Intelligence, Part 2: Copyrightability,” 2025. https://www.copyright.gov/ai/Copyright-and-Artificial-Intelligence-Part-2-Copyrightability-Report.pdf ↩
Ghostty, “AI Usage Policy,” GitHub. https://github.com/ghostty-org/ghostty/blob/main/AI_POLICY.md ↩ ↩²
S. Levin, “docs: remove Assisted-by references,” LWN.net. https://lwn.net/Articles/1099653/ ↩
Gentoo Council, “AI policy,” Gentoo Wiki. https://wiki.gentoo.org/wiki/Project:Council/AI_policy ↩
NISO, “CRediT - Contributor Role Taxonomy,” credit.niso.org. https://credit.niso.org/ ↩
IBM Research, “AI Attribution Toolkit,” IBM Research Blog. https://research.ibm.com/blog/AI-attribution-toolkit ↩
IBM Research, “constants.ts,” aiattribution.github.io source, GitHub. https://github.com/aiattribution/aiattribution.github.io/blob/main/src/lib/components/create-attribution-statement/constants.ts ↩
Amazon, “Content Guidelines,” Kindle Direct Publishing Help. https://kdp.amazon.com/en_US/help/topic/G200672390 ↩

Linked from

Link graph: 2 docs link here, this page links to 8