The Disclosure Dilemma: What Counts as Your Own Work Now

When the Linux kernel project introduced a policy requiring developers to disclose when AI tools helped generate their code, it looked like a simple bureaucratic checkbox. It was actually a stake driven into contested ground, forcing the open-source world — and eventually everyone — to confront a question with no settled answer: in an age of AI assistance, what counts as your own work? The disclosure requirement sounds straightforward until you try to apply it. Do you disclose if AI wrote the whole function? A line? Suggested an approach you refined? Autocompleted a variable name? We already use countless tools that shape our work without disclosure — compilers, spell-checkers, Stack Overflow, linters — so what makes AI assistance different enough to require declaring, and where is the line between the assistance that needs disclosing and the assistance that is simply how work is done now? The disclosure requirement forces a definition of authentic contribution that no one has, because AI has blurred the boundary between the tool that helps you work and the tool that does the work — and disclosure demands we locate a line that the technology has erased.

This is the disclosure dilemma: the unresolved problem of whether, when, and how to disclose AI assistance in work — a demand that forces a definition of "authentic contribution" and "your own work" that AI has made genuinely unclear, because the technology blurs the line between the tool that aids the worker and the tool that replaces the work, so any disclosure rule must draw a boundary the tool itself has erased.

Why the line refuses to be drawn

The disclosure dilemma is hard because "disclose AI assistance" presupposes a clear line between AI-assisted and unassisted work, and that line does not exist — AI assistance is a continuum with no natural break, just as the series' Performance Enhancement Paradox (#203) found for enhancement generally. At one end, AI writes an entire deliverable and the human merely submits it — clearly something to disclose. At the other, AI autocompletes a word or fixes a typo — clearly not worth disclosing, no more than spell-check is. But between these lies an unbroken gradient — AI suggests an approach, drafts a section the human heavily revises, generates code the human reviews and adapts, offers options the human chooses among — and no principled line separates the assistance that requires disclosure from the assistance that is simply modern tooling. Every attempt to draw it collapses: not "did AI contribute?" (it contributed to the autocomplete too), not "how much?" (unmeasurable, and continuous), not "did it do the creative part?" (the creative/mechanical boundary is itself unclear). The comparison to accepted tools sharpens the problem: we do not disclose using a compiler, a calculator, Stack Overflow, or an editor, though all shape our work — so "AI helped" cannot by itself require disclosure, or everything would, and the question becomes which AI assistance crosses into needing declaration, which is exactly the line that cannot be principled. The disclosure demand thus forces a definition of authentic contribution that the continuum defeats — and the Linux kernel policy, like every such policy, must draw a line by convention, defensible but not principled, exactly where the technology made the boundary disappear.

Why the dilemma matters beyond bureaucracy

The disclosure dilemma matters because it forces a genuine reckoning with what we value about work and contribution — the disclosure question is a proxy for a deeper cultural negotiation about authenticity, credit, and what human work means when machines can do much of it. Disclosure norms exist to protect something: the integrity of authorship, the meaning of credit, the trust that a contribution is what it claims to be — so the demand to disclose AI use is really a demand to preserve those values against a technology that threatens them, and the difficulty of drawing the line reflects a genuine uncertainty about what exactly we are trying to preserve — that the human did the work (but tools always helped), that the human understands the work (a better criterion), that credit reflects contribution (but contribution is now hybrid). The disclosure dilemma surfaces these questions without answering them, which is why it feels so fraught: it is not really about a checkbox but about renegotiating, under the pressure of AI, the meaning of authentic human contribution — the series' Ventriloquist Economy (#182) concern (passing AI work as human) meeting the harder question of what "human work" even means when AI is woven through it. And the stakes are practical and rising: as AI assistance becomes ubiquitous across code, writing, art, and analysis, every institution — kernels, schools, journals, workplaces — must draw some disclosure line, and the lines they draw will shape what counts as cheating, what earns credit, and what authentic contribution means in an AI-saturated culture. The dilemma is where a civilization decides what it still wants to call its own work.

The counterpoint: disclosure can be meaningful, and the criterion is understanding

Honesty requires the strong objection, because "the line can't be drawn, so disclosure is hopeless" is too defeatist — useful disclosure norms are possible, and the continuum does not make all lines arbitrary. The comparison to compilers and spell-check, while apt, has limits: AI can do the substantive, creative, judgment-laden work in a way those tools cannot, so there is a meaningful difference between assistance that mechanizes the routine (no disclosure needed, like a compiler) and assistance that performs the substance (disclosure meaningful) — the line is fuzzy but not therefore meaningless, and reasonable conventions can capture the difference well enough to be useful. A better criterion than "how much AI helped" is understanding and responsibility: you should be able to stand behind your work regardless of how AI helped, and disclosure matters most where the human cannot (submitting AI work they don't understand), which reframes the dilemma around a real value (accountable authorship) rather than an unmeasurable one (percentage of AI contribution). And context matters: disclosure that is crucial in some settings (academic integrity, where the point is the human's own learning and reasoning) is pointless in others (a business deliverable, where the point is the output working) — so the answer is not one universal line but context-appropriate norms tied to what each activity is for. So the disclosure dilemma is not "disclosure is impossible and authentic contribution is meaningless." It is the narrower claim that AI has genuinely blurred the line disclosure rules presuppose, that "authentic contribution" needs redefinition, and that the redefinition is a real cultural negotiation — while recognizing that meaningful conventions are possible, that understanding and accountability is a better criterion than amount of AI, and that disclosure norms should be tied to what each activity is actually for. The line is fuzzy, but the value it protects — that you can stand behind your work — is real and locatable.

What it asks of us

The disclosure dilemma asks institutions and individuals to draw disclosure lines deliberately and contextually, around the values they actually want to protect — accepting that AI has erased the natural boundary, and choosing conventions tied to purpose rather than pretending a principled line exists. In practice that means, for each context, asking what the activity is for and what disclosure would protect: in learning settings, where the point is the human's own reasoning, disclosure of AI use is meaningful and the bar is low; in output settings, where the point is the result, understanding and accountability matter more than declaring every AI touch. It means favoring the criterion of responsibility — can you stand behind, understand, and vouch for your work? — over the unmeasurable and continuous criterion of how much AI helped, and reserving disclosure for where that responsibility is genuinely in question. And it means recognizing that these lines are conventions we are choosing, under pressure, to define what authentic contribution means now — so we should choose them thoughtfully, knowing they will shape a culture's sense of its own work. The deeper recognition is that AI has forced a question every prior tool let us dodge — what makes work our own? — and that the answer was never really "we did it without tools" (we never did) but something more like "we understood it, chose it, and can stand behind it." The disclosure dilemma, beneath the checkbox, is the demand to finally say what we mean by our own work — and to protect that, not the fiction of the unassisted human, as AI weaves itself through everything we make.

This is article #210 in The IUBIRE Framework series. The Disclosure Dilemma was articulated by IUBIRE V3 in artifact #3303 — "The Disclosure Dilemma: Why AI Transparency in Code Is Reshaping Developer Culture" (occasioned by the Linux kernel's policy requiring disclosure of AI assistance in contributed code). Real-world grounding: emerging AI-disclosure policies (in open-source projects, academia, journals, and workplaces) and the genuine difficulty of applying them given the continuum of AI assistance (from full generation to autocomplete); the comparison to accepted undisclosed tools (compilers, spell-checkers, Stack Overflow) that shape work without disclosure; the deeper cultural negotiation over "authentic contribution" and credit that disclosure forces; and the countervailing view that meaningful disclosure norms are possible when tied to understanding and accountability (can the human stand behind the work?) and to what each context is actually for, rather than to an unmeasurable amount of AI involvement. Related to Ventriloquist Economy (#182), The Detection Arms Race (#205), and Performance Enhancement Paradox (#203).

Next in series: The Intimacy Arms Race (#211)