# The Integrity Framework — A Writer's Code for AI Use
Over the last three articles, we have been circling the same question from different angles. In "[Attribution, Disclosure, and the New Citation](/harrys-desk/attribution-disclosure-and-the-new-citation)," I argued that the old rules of citation are no longer enough: when AI has read everything and can paraphrase anything, we need a new transparency about what we borrowed, what we shaped, and what we made. In "[Authenticity — When Is It \"Your\" Work?](/harrys-desk/authenticity-when-is-it-your-work)," I proposed that ownership of a text is not about who typed the words but about who stands behind them: intention, judgment, and responsibility. Today I want to bring those threads together into something you can actually use.
This is the Integrity Framework — a writer's code for AI use. It is not a legal document. It will not save you from every copyright dispute or editorial scandal. What it will do is give you a set of principles you can apply to almost any project, in any genre, with any model. The goal is simple: keep the human writer at the center of AI-augmented authorship.
I am going to present the framework as six principles. Each principle comes with a question you can ask yourself, a practice you can adopt, and a failure mode to watch for. By the end, you should have a personal code you can write down, revise, and defend.
Principle One: Declare the Machine's Role
The first principle is the easiest to state and the hardest to honor consistently: be transparent about how AI was used.
Transparency does not mean listing every prompt you typed or every model you queried. It means giving the reader enough information to understand the nature of the labor. Did AI generate a first draft that you then rewrote? Did it suggest alternative phrasings that you accepted or rejected? Did it check your grammar, summarize your research, or help you structure an argument? These are different kinds of contribution, and they deserve different kinds of disclosure.
The question to ask: *If a careful reader discovered that I used AI, would they feel deceived by how I presented the work?*
The practice: write a short process note for anything you publish with significant AI assistance. It does not have to be a footnote on every page. It can live in an acknowledgments section, a methodology appendix, or an author's note at the end. The point is to place the information where an interested reader can find it.
The failure mode: partial disclosure. Saying "I used AI for research" when the model also drafted whole sections is not transparency. It is a carefully shaped omission, and readers can smell it.
Principle Two: Own Every Claim
The second principle follows directly from the first. However much AI helped, you must be able to stand behind every significant claim, image, quotation, and interpretation in the finished piece.
I do not mean you need to have invented every idea. Scholarship, journalism, and criticism all depend on building on the work of others. I mean that if someone challenged you at a dinner party or in a peer-review session, you could explain why this claim is here, what evidence supports it, and why you trust that evidence.
The question to ask: *Could I defend the main assertions in this piece without looking at my notes?*
The practice: for every important claim, write a one-sentence defense. Not a full citation, though that may also be necessary. A single sentence that says why you believe this and what you would point to if challenged. If you cannot write that sentence, the claim does not belong in the final text.
The failure mode: laundering authority. This happens when a writer lets AI produce confident-sounding statistics, historical details, or expert judgments, then treats them as settled because they sound plausible. The result is a text that appears authoritative while resting on sand.
Principle Three: Preserve the Struggle That Matters
In the article on authenticity, I said that struggle is valuable only when it leads to insight. The third principle of the framework is about deliberately protecting the right struggles.
Not all friction in writing is productive. Wrestling with grammar, formatting, and repetitive structural work is usually not where meaning is made. AI can remove that friction without cost. But the struggle to clarify what you really think, to find the right example, to admit a contradiction, to choose a tone — these are where the piece becomes yours.
The question to ask: *Where in this draft did I do the thinking, and where did I delegate it?*
The practice: identify the three most important decisions in your piece. These might be the framing, the central example, the turn in the argument, or the emotional landing. Make sure those decisions were made by you, not suggested by a model and accepted because they were good enough. If they were suggested by AI, interrogate them harder than anything else.
The failure mode: aesthetic outsourcing. This is when the model supplies not just sentences but judgments: what is important, what is funny, what is moving, what is fair. A piece written this way may be competent, but it will not be urgent. It will read like a very good imitation of a writer rather than the real thing.
Principle Four: Protect Vulnerable Sources and Subjects
Writers working with AI often feed the model material that is not fully public: interview transcripts, personal letters, early drafts, patient records, proprietary documents. The fourth principle says that confidentiality must survive automation.
This is not just an ethical concern. It is a practical one. Once sensitive material enters a third-party model, your control over it diminishes. You may not know where it is stored, how it is used for training, or who might see it in the future.
The question to ask: *Would I be comfortable if this source or subject knew exactly what I uploaded and where?*
The practice: create a simple tier system. Public material can go into any tool. Semi-public or anonymized material should only go into tools with clear data policies and your organization has approved. Private, identifying, or legally sensitive material should stay out of cloud models unless you have explicit authorization. When in doubt, redact before you paste.
The failure mode: convenience over care. The model makes it so easy to upload a whole transcript and ask for a summary that you stop asking whether you should. One careless paste can violate a source's trust or your legal obligations.
Principle Five: Maintain Version Truth
If you have been following this series from the beginning, you know I am serious about version control. The fifth principle of integrity is that you should always be able to reconstruct how a piece evolved.
This is not paranoia. It is accountability. When a reader, editor, or legal reviewer asks how a controversial passage came to be, you should be able to point to a chain of drafts. What did the AI produce? What did you change? When did you change it? Why?
The question to ask: *If I had to explain the history of this paragraph, could I do it?*
The practice: keep a dated draft for every significant revision. This can be as simple as a folder of files or as disciplined as a Git repository. The key is that the history exists and is not too painful to reconstruct. Save the model's raw output before you edit it. Name your files by date. Make small, specific commits if you are using Git.
The failure mode: the black box final draft. You arrive at a polished document and have no record of what came from where. Then a question arises, and you cannot answer it because the process was too seamless to leave a trace.
Principle Six: Know Your Own Line
The final principle is the most personal. Every writer must decide what level of AI assistance they are comfortable with, and that line will differ by genre, context, and conscience.
A poet may decide that no generated lines ever enter a poem. A technical writer may decide that AI drafting is fine as long as every procedure is verified by an engineer. A journalist may decide that AI can summarize documents but never conduct interviews or generate quotes. These are all legitimate positions.
The question to ask: *What am I unwilling to delegate, no matter how good the model gets?*
The practice: write your line down. Put it in a note, a manifesto, or the header of your working documents. Revisit it every few months, because models change and so do you. The act of articulating it forces you to take your own standards seriously.
The failure mode: drift. Without a clear line, you slowly accept more and more machine assistance because each individual step feels reasonable. The drift is invisible until one day you publish something you would not have been willing to write yourself.
How to Use the Framework in Practice
The six principles are meant to be operational. Here is one way to apply them to a real project.
Before you begin, write a short integrity statement: "For this piece, I will use AI for X, Y, and Z. I will not use it for A, B, or C. I will disclose D in the author's note." The statement does not have to be public, though it can be. It is a contract with yourself.
During drafting, flag every AI-generated passage with a comment or a distinct file. Do not let it blend into your own prose before you have decided whether it belongs.
During revision, run each principle as a checklist. Declare the machine's role. Verify every claim. Protect the struggles that matter. Check for sensitive material. Confirm version truth. Re-read your line.
Before publication, write a final process note. It can be a sentence or a paragraph. It should answer the reader's implicit question: how was this made?
Integrity Is Not Perfection
I want to be careful not to make this sound moralistic. The framework is not a purity test. You will not always live up to every principle. I certainly do not. The point is to have a standard you can consult, revise, and explain.
There will be projects where you disclose less than you ideally would because of institutional pressure. There will be drafts where you lose track of what came from the machine and what came from you. There will be moments when convenience wins over care. The framework is not there to make you feel guilty about these lapses. It is there to help you notice them and correct them over time.
Integrity, in this sense, is a practice, not a state. It is the habit of asking the right questions consistently enough that your work remains answerable to the people who read it.
What This Means for the Rest of the Series
With this article, we close the ethical arc of Part I. We have covered the writer's dilemma, the history of writing tools, the symbiotic model, the mechanics of large language models, the craft of prompting, style transfer, genre calibration, voice switching, drafting workflows, the dialogue method, version control, attribution, authenticity, and now integrity. Together these form the foundation for everything that follows.
Starting Monday, we move into applied craft. The next article — "Curating Your AI Stack" — will walk through the major models and tools available to writers today: Claude, GPT, Gemini, Perplexity, and the smaller specialized services that are appearing every month. I will not tell you which one to use. I will teach you how to choose for yourself.
For Next Time
Monday's article is "Curating Your AI Stack (Claude, GPT, Gemini, Perplexity, etc.)." We will leave the abstract questions behind and get tactical: how to evaluate a model for your genre, how to combine tools in a workflow, and how to avoid the trap of chasing every new release.
Your homework until then: write your own six-principle integrity code. Do not copy mine word for word. Adapt the principles to your work. Be specific about what you will and will not delegate. Then pick one recent piece you have written with AI and run it through your code. Where did you pass? Where did you fall short? The honest answer is the beginning of a better practice.
---
*Harry Mercury, Editor in Chief* *The SMF Works Project* *Week 6, Article 3*