Hello, DEV community! 👋
This is my first post here. I've been reading articles on this platform for a while, but a recent article by @pascal_cescato_692b7a8a20 - "The "AI" Badge Doesn't Measure What You Think It Does" - finally pushed me to join the conversation.
It touches on a topic that's been on my mind for a while: the "AI-generated" badge, which is being actively pushed across media platforms, doesn't actually tell us anything useful.
Whose thought is it anyway?
As Pascal brilliantly breaks down, we constantly conflate three fundamentally different ways of working:
- Assisted. When the idea, structure, and artificial decisions belong entirely to the human. A model is used to rephrase, translate, fix regex, or pressure-test arguments.
- Generated. A human gives a prompt, but the model produces the actual thought and text.
- Produced. Automated pipelines generating content at an industrial scale without human oversight.
A binary badge (or statistical watermark) treats all three identically. An engineer who spends hours architecting a system, writing core logic, and using LLM to polish a comment or write boilerplate get shoved into the same bucket as an automated spam farm.
The real line of ownership isn't drawn by how much a model intervened, but by who kept their hand on the decisions. Who designed the solution? Who discarded the bad outputs? Who took responsibility for the final architecture?
Proof of work instead of broken labels
Detectors and badges look at the final shape of a file and guess its origin. But as Pascal proved by running his 2021 pre-LLM article through ZeroGPT (getting scores ranging from 97% to 8.6%), detectors merely chase stylistic neutrality, not actual origin.
We are seeing the exact same flaw happening in programming. Today, there are various code analyzers and enterprise tools designed to detect "AI-generated code". While writing software is fundamentally different from writing prose, the detection methodologies share the exact same underlying bias.
Just as text detectors flag well-structured, pedagogical paragraphs as "AI," code detectors often flag clean, canonical, and boilerplate code. If an engineer writes a textbook algorithm, strictly follows naming conventions, or implements standard design patterns, they risk being falsely flagged. The detector mistakes professional standardization for machine generation. It judges the final shape without knowing the process.
This exact problem led me to create dev-ledger - an open-source VS Code extension designed as a conceptual evolution of time-trackers like WakaTime.
But unlike traditional trackers that send your activity to a third-party server, dev-ledger is 100% local-first. All data collection and behavioral analysis happen directly on your machine - no APIs, no telemetry, no cloud. To guarantee the authenticity of your timeline, it secures your local event log with a cryptographic hash chain. It gives you a mathematically tamper-proof "Proof of Work" that you fully control, without sacrificing your privacy.
Instead of slapping a meaningless "100% Human" or "AI Generated" badge on a project, this approach shifts the focus back to transparency. By unobtrusively recording keystrokes, active editing time, and structural modifications, it documents the actual process - the iterations, the refactoring, and the human effort behind a codebase. It then converts this data into automated reports and visual SVGs for your README.md, backed by an integrity hash.
When someone looks at a repository equipped with this kind of timeline, they don't have to blindly trust a flawed detector or guess the code's origin based on its "final shape." They can actually see the chain of decisions and the problem-solving process that went into building it.
We probably can't stop platforms from implementing broken AI detectors or pushing binary badges. But as engineers, we can choose to shift the conversation back to what actually matters: the depth of our thought and the transparency of our work.
If you share this philosophy and want to secure the integrity of your own coding sessions, you can check out the source code and try the extension here:
👉 github.com/whaiman/dev-ledger
(Feedback, GitHub stars, and PRs are deeply appreciated!)
What Metrics Cannot Fix
Building a cryptographic ledger for development activity solves the technical problem of proving effort, but it doesn't fix the social one.
Having a verified hash chain won't stop a cynical reviewer on Reddit or Hacker News from glancing at a clean, well-structured repository and dismissing it as "LLM slop." Just as in writing, the technical demonstration and the social judgment are two completely different things. Often, the reflexive rejection of code as "AI-generated" has nothing to do with the code itself - it’s just a blunt reaction to the anxiety of our industry's current transition.
If badges can't measure origin, and enterprise code detectors can't measure thought, then the question in modern software engineering isn't "who typed this line?" but "who holds the steering wheel?"
Software architecture is fundamentally about making trade-offs, not just generating syntax. An LLM might help write a boilerplate function or figure out a tricky regex, but it doesn't conceptualize a local-first system. It doesn’t weigh the security implications of a cryptographic hash chain against a centralized database. The engineering intent - the real heavy lifting - remains entirely human.
When we reduce a developer's contribution to a binary label, we erase the unseen hours spent designing data models, debugging AI hallucinations, and rejecting bad abstractions. We erase the actual engineering.
Code analyzers and enterprise detectors will only ever scan the final repository. They parse the Abstract Syntax Tree (AST) looking for generic patterns, completely blind to the iterative struggle that brought that structure into existence. But true ownership of software isn't found in the finalized syntax. It lives in the problem-solving, the discarded ideas, and the chain of architectural choices that made that code necessary in the first place.
