"AI generated" is the wrong question

I keep coming back to one question:

Why do we keep trying to answer AI involvement with a yes/no label?

Most discussions around AI content still end up somewhere around this:

AI generated: true

or:

AI generated: false

That looks simple. It is also not very helpful.

Because the moment you look at how real content is created, the binary label breaks down.

If I have a technical idea, bring in my own experience, define the direction, collect the facts, and then use an AI system to help with structure and wording, that is one kind of workflow.

If a system takes a short prompt and automatically generates thousands of articles, that is a very different workflow.

Both could get the same lazy label: "AI generated".

That is the part that bothers me.

The interesting question is not whether AI was involved

For me, the better question is:

Who contributed what?

That sounds like a small wording change, but it changes the whole discussion.

I do not really care if somebody used AI for grammar, translation, structure, brainstorming, or even drafting. I care much more about whether the human had the idea, whether the facts were checked, whether the AI output was reviewed, and whether the publisher can explain the workflow.

There is a big difference between these cases:

• A human writes a post and uses AI for wording improvements.
• A human provides the idea, facts, and opinion, while AI helps turn it into a readable draft.
• Several AI systems perform research, drafting, translation, and summarization.
• AI generates the whole thing from a short instruction.
• AI drafts something, but a human fact-checks, edits, and approves it.

Putting all of that into one box is just too coarse.

That was the starting point for HACP.

What HACP is

HACP stands for Human-AI Contribution Provenance.

It is an experimental draft specification for describing how humans and AI systems contributed to digital content.

The repository is here:

https://github.com/SBajonczak/hacp-spec

There is also a reference viewer here:

https://github.com/SBajonczak/hacp-viewer

The viewer can render HACP workflows as a graph, timeline, or compact view. That part matters to me because provenance should not only be something machines can parse. A normal person should also be able to look at it and understand roughly what happened.

Important disclaimer: HACP is not an established standard. It is a draft. Version 0.2 exists, with a JSON Schema, examples, and a reference viewer. That is it for now.

No big claims.

No "future of the web" nonsense.

It is an open experiment.

HACP is not an AI detector

This is probably the most important distinction.

HACP does not try to guess whether something "sounds like AI".

It does not analyze writing style.

It does not produce an AI probability score.

It does not say:

This article is 73% AI.

I do not think that is a good direction anyway. At least not for this problem.

HACP is about declared provenance. It describes what the issuer says happened during the creation workflow.

That means a normal HACP manifest is not proof by itself. It is a provenance statement.

If I publish a manifest saying that I wrote the concept and AI helped with wording, that is my declaration. It may be honest, but the manifest alone does not cryptographically prove it.

That distinction is important.

Later, there could be attestations. For example:

• an AI provider confirms that a specific workflow step happened,
• a publisher confirms that a human reviewed and approved the content,
• C2PA or a similar provenance infrastructure handles signatures, content binding, identity, and verification.

But HACP v0.2 does not magically verify those claims.

And it should not pretend to.

The basic model

The current draft is built around a few simple pieces:

1. systems
2. workflow
3. contributions
4. influence
5. dependsOn

A system describes an AI provider or model that was involved.

A workflow contains the steps.

A contribution says what the actor did.

Influence describes how much that actor shaped the specific step.

And dependsOn describes which steps rely on earlier steps.

A small example looks like this:

{
  "specVersion": "0.2",
  "summary": {
    "aiInvolvement": "collaborative"
  },
  "systems": [
    {
      "id": "sys-ai-writing",
      "provider": {
        "name": "Example AI Provider"
      },
      "model": {
        "name": "Example Writing Model"
      }
    }
  ],
  "workflow": [
    {
      "id": "step-1",
      "sequence": 1,
      "actor": {
        "type": "human",
        "role": "author"
      },
      "contributions": [
        "concept",
        "expertise",
        "facts",
        "creative-direction"
      ],
      "influence": "primary"
    },
    {
      "id": "step-2",
      "sequence": 2,
      "dependsOn": [
        "step-1"
      ],
      "actor": {
        "type": "ai",
        "systemId": "sys-ai-writing"
      },
      "contributions": [
        "structure",
        "drafting",
        "wording",
        "editing"
      ],
      "influence": "substantial"
    },
    {
      "id": "step-3",
      "sequence": 3,
      "dependsOn": [
        "step-2"
      ],
      "actor": {
        "type": "human",
        "role": "author"
      },
      "contributions": [
        "fact-checking",
        "review",
        "approval"
      ],
      "influence": "primary"
    }
  ]
}

That is already more useful than AI generated: true.

You can see the human concept, the AI assistance, and the final human review. You can also see that the AI step depended on the human step, and the final approval depended on the AI-assisted draft.

It is not perfect. But it is much closer to how real content gets made.

Why influence is not a percentage

One thing I deliberately avoided is percentage scoring.

Something like this looks precise:

Human: 37%
AI: 63%

But in many workflows that number would be fake precision.

How do you measure that?

By word count? Then an AI that rewrites a human idea into cleaner prose gets a high score, even if the original thinking came from the human.

By time spent? Then a slow human gets more "authorship" than a fast one.

By semantic importance? Good luck measuring that consistently.

So HACP v0.2 uses qualitative influence values:

• minor
• supporting
• substantial
• primary

That is less mathematically satisfying, but probably more honest.

The value describes the influence on a workflow step. It is not a legal statement about copyright. It is not a precise measurement of intellectual ownership. It is a way to describe the shape of the workflow without pretending that we can calculate authorship like a spreadsheet.

More than one AI system

Another thing I wanted to support from the beginning: multiple AI providers.

A real workflow might look like this:

Human → Claude → OpenAI → DeepL → Human

One system might help with research. Another might draft. Another might translate. The human might then fact-check, rewrite parts, and approve the final version.

If we only write "AI was used", all of that disappears.

HACP allows each AI step to reference a system. That means the manifest can say which provider and model were involved, at least when that information is known.

That last part matters.

If the model is known, put it in.

If it is not reliably known, do not invent it.

A placeholder is better than a fake provenance claim.

Where C2PA fits in

HACP is not meant to replace C2PA.

I see the two things solving different parts of the problem.

C2PA and similar provenance infrastructure are about trust mechanics:

• signatures,
• content binding,
• signer identity,
• verification,
• trust chains.

HACP is about contribution semantics:

• who contributed,
• what they contributed,
• which actor was human or AI,
• how the workflow was ordered,
• which steps depended on each other,
• how influential each actor was in a step.

So the idea is not "HACP instead of C2PA".

The idea is more like:

C2PA can help prove that a signed provenance package belongs to a piece of content.

HACP can describe the human and AI contribution workflow inside that provenance data.

At least that is the direction I am exploring.

Again: not implemented as a verified C2PA integration today. The current draft only describes how the semantics could fit together.

Why I published it

I am not a standards body.

I am not a big AI provider.

But I had the idea, and it kept making sense to me. So I decided to do the practical thing and put something real on GitHub.

That means:

• a draft specification,
• a JSON Schema,
• example manifests,
• a reference viewer,
• and enough structure that other people can tell me where it is wrong.

Maybe the idea is useful.

Maybe it is missing something obvious.

Maybe the vocabulary is too small, or the trust model needs to be shaped differently, or the workflow model needs better support for partial documents.

That is exactly why I do not want this to sit in a private notes file.

If the idea is weak, it should break in public.

If it is useful, real use cases will make it better.

Dogfooding this article

This article itself is a HACP example.

The concept, direction, facts, and decision to publish come from me.

AI helped with structure, drafting, wording, and editing.

That workflow is exactly the kind of thing I want HACP to express.

Not because the AI involvement is shameful.

Not because the human involvement needs to be defended.

But because the binary label loses the interesting part.

This article is not simply "AI generated".

It is also not "AI free".

It is a human-led article with AI assistance in the writing process and human review before publication.

That is the messy middle where a lot of modern content already lives.

We should have better metadata for it.

Current status

The HACP spec is currently an experimental v0.2 draft.

You can find it here:

https://github.com/SBajonczak/hacp-spec

The reference viewer is here:

https://github.com/SBajonczak/hacp-viewer

The viewer currently focuses on making HACP manifests readable as graph, timeline, and compact views.

There is no public live demo URL I can point to right now, so I will not invent one. If that changes, I can add it later.

What I want feedback on

The parts I am most interested in are practical ones:

• Is the contribution vocabulary useful enough?
• Are the influence values understandable?
• Does the workflow model handle real human-AI collaboration?
• How should attestations work without making the simple case too complex?
• Where should HACP stop and where should C2PA or another trust layer begin?

I am especially interested in real workflows.

Blog posts are one example. But the same question appears in documentation, research notes, marketing pages, product descriptions, support articles, images, videos, code, and probably a lot of internal enterprise content.

The important part is not to punish AI usage.

The important part is to describe it properly.

I do not know if HACP will ever become more than this experiment.

But I think the question is worth discussing in the open.

HACP provenance: This article uses a declared HACP v0.2 manifest in the Ghost head code injection. It is not cryptographically verified and does not claim provider or C2PA attestation.