ADP: Reusable Claude Artifacts, Reviewed
Artifacts Done Properly (ADP) is a Claude skill and plugin, not a hosted product, an app builder, or a new model. It treats a Claude Artifact as a page made of addressable parts, keeps a record of every change, and exposes reusable pieces as a catalog that another page can take by reference. The repository is seven days old at the time of writing. That age matters more than the pitch.
GitHub showed 48 stars, 2 forks, seven open issues and pull requests, and Apache-2.0 licensing on 19 November 2026. The latest release was v2.1.2, the fourth release since 15 November. The catalog lists 141 entries. Of those, 137 carry the status new and four carry stable. That is not a criticism by itself, but it is the right frame for the rest of this review: ADP is an early, active attempt to define a shared record layer for Claude Artifacts, not a settled standard.

The hard problem is the second edit.
A Claude Artifact starts as a single page. It is easy to generate, easy to publish, and easy to lose the structure of once another session edits it. The second session may have an older copy. A comment points at a screen position that no longer exists. A useful table or chart is copied into the next page as markup, not as a component with an interface. The iteration ends, and the value stays in a chat history or a file that the next project cannot inspect.
ADP’s answer is to make the page’s structure explicit before the next edit happens. Every piece of the page is a part with a stable id and a content hash. Comments anchor to part ids. The page’s copy and the record live in ArtifactData collections. An edit follows a read, hold, publish, record protocol. The catalog is the reuse side of the same idea: a part can be taken by reference, with its dependencies, instead of being pasted as new source.
That is a real gap. Native artifacts and a Git repository can version source, but they do not give a page a part-level manifest, a dependency-aware component catalog, or a comment anchor that survives a rewrite. A design system can share components, but it does not record who changed which part of a published artifact. ADP tries to put those pieces in one place.
What the mechanism actually does
The repository’s own architecture document is unusually specific, which makes it possible to separate the working parts from the marketing. Three pieces matter.
Parts and hashes. A part is the text between markers such as <!-- part:triage.keys-table --> and its closing marker. The normalized text is hashed with SHA-256, truncated to 12 hex characters. The page hash is a hash of the sorted part hashes and file hashes, so a change shows on the part and every ancestor that contains it. The runtime in adp.js re-implements the same rules as adp.py, and the repository has parity tests for the page and part hashes. This is the foundation. Without it, the rest is just a comment widget with extra steps.
The record. The record is a set of ArtifactData documents: manifest/current, parts/<id>, content/<part id>, changes/<id>, decisions/<slug>, incoming/<pid>, and request and presence records for the assistant template. The loop commands export, classify, propose, and ack compare a local working copy with the live page. The classification table distinguishes new, ours, theirs, applied, retired, and held. A hold blocks a write rather than overwriting someone else. That is the most valuable engineering idea in the project: a conflict model for artifact edits, not just a version number.
The catalog. The catalog is 141 entries with headers that declare an id, kind, group, status, version, requires, provides, and files; optional tags, config signatures, and sample references fill out the index. adp.py take resolves the entries and their dependencies and prints a files map by reference. The page can take a table, a chart, a layout, or a theme without copying the source into the page. The catalog also ships templates: starter, assistant, and default. The assistant template adds the Work with Claude pane, Requests, and presence; the default template builds on it with the full kit, extra layouts, patterns, and visualizations, including 3D.
The tool is deliberately offline in one respect: adp.py computes hashes and diffs and prints the native Artifact and ArtifactData calls; it does not make the calls itself. An authorized agent executes them. That keeps the command-line tool portable and testable, but it also means the workflow is only as reliable as the agent that follows the printed calls.
What is genuinely differentiated
The part hash and the comment anchor are not decorative. They make a rewrite reviewable at the level people actually discuss: this table, this chart, this paragraph. The read, hold, publish, record protocol is more than a lock; it creates an audit trail that can say who changed which part, against which base, and why. The classification of held versus retired is the kind of detail that only appears after a team has lost work to a concurrent edit.
The catalog-by-reference idea is also stronger than a folder of copied snippets. A copied component is frozen at the moment of the copy. A reference can carry a declared dependency graph and a version. Whether the current catalog is mature enough to deliver on that promise is a separate question, but the interface is right.
The project also does the unglamorous work: a Python standard-library CLI, a Node runtime, 34 test files, CI with ruff, unittest, packaging, and a catalog roundtrip. The release history is rapid, and the documentation is candid about limits. That combination is more credible than a demo page with a waitlist.
Where it breaks, and why that matters
It is a Claude-first layer; portability is still early. Claude is the default host. The OpenAI Sites transport is explicitly experimental. A local adapter, a Hermes adapter, and a Codex companion are open issues, not shipped parity. The host-adapter document says the contract is partly implemented and that no Space installation has been validated. If your team does not live in Claude Artifacts, most of the value is unavailable today.
The catalog is broad but early. The 141 entries are real files with hashes and headers, but 137 are marked new. The README itself lists two missing pieces: adp.py new --tier full is not available, and there is no catalog entry-add command; adding an entry means editing files and rebuilding the index. A large catalog of new entries is a good demo of the mechanism, not proof that every component has survived production use.
The one-file path has explicit holes. The single-file pack does not cover module scripts, relative images, or CSS url(), and the packed page must stay under 16 MB. Publishing is split at 250 files. Those limits are documented, which is good, but they are the difference between a demo artifact and a site with normal front-end assets.
It is not a software production system. ADP does not provide a backend, authentication, authorization, a deployment target, a package manager, or a general build pipeline. It runs on the host’s data store and the host’s publish mechanism. The repository’s own docs say the page declares database rules; it does not enforce them, and the platform remains the authority. A browser flag is not an authorization boundary. For a production application, that is a design constraint.
Portability is manual. The records shell can move a page’s records between Claude and Sites, but there is no automatic sync. Source revision, publication version, deployment version, and record revision are separate evidence. An import is a plan plus guarded writes plus readback. That is honest engineering, but it is not the “take your artifact anywhere” story a casual reader may hear.
The adoption gate can be gamed. Open issue #99 describes an adoption run that passed parity with an opaque compiled React bundle inside an ADP shell, without real parts, copy as data, or seeded records. The maintainers are discussing it. The lesson is general: a pixel-parity check is not a structural check, and a protocol that claims to preserve structure needs a gate that can tell the difference.
One project, one protocol. The architecture document calls ADP a standard, but there is one implementation, one catalog URL, and one primary author in the plugin metadata. That is not disqualifying at seven days old. It does mean the project has not earned the word “standard” yet. The compatibility surface also has a naming collision: the installation guide warns that the plugin named adp is a different project, the Artifact Data Protocol.
Compared with the alternatives
| Approach | What it gives you | Where ADP differs |
|---|---|---|
| Native Claude Artifacts | Fast generation, a published page, and a version history. | ADP adds a part manifest, part-level comment anchors, a change record, and a catalog. It also adds ceremony that a one-shot artifact does not need. |
| shadcn/ui and similar source distributions | Readable component source that you own and can edit. | ADP’s catalog is host-native and by reference, with declared dependencies. It is not a replacement for a code component library, and it does not give you a normal package manager. |
| Storybook | Component development, documentation, and visual testing. | ADP records how a published artifact changes. It is not a component workbench or a visual regression suite. |
| Bit | A versioned component registry with independent builds. | ADP is much lighter and tied to the artifact host. Bit is heavier and independently buildable. They solve different layers. |
| Backstage or an Nx monorepo | A developer portal or a monorepo for many projects. | ADP is page-level. It does not replace repository orchestration, ownership catalogs, or CI for a codebase. |
| Retool, Appsmith, Budibase | Internal app runtimes with data connections and deployment. | ADP is not an app runtime. It records and composes an artifact; it does not host a backend or manage production access. |
| v0, Lovable, Bolt | Generation of an app or page from a prompt. | ADP starts after generation. It is a record and reuse layer, not a generator. |
| Notion or Coda | Collaborative documents with comments and databases. | They are document tools, not code-artifact runtimes. ADP’s parts are code and markup with hashes. |
| OpenAI Sites or Canvas | Another host for generated artifacts and pages. | ADP has an experimental Sites transport and a records shell. It does not claim host parity yet. |
The closest comparison is the combination of native artifact versioning, a code repository, and a comment thread, not a design system or an app builder. ADP is trying to make those three cooperate at the level of a part. If that sounds like a small problem, it is not: it is the difference between a page that can be edited by three sessions and a page that has to be regenerated to be safe.
Did it need to exist?
Yes, for a narrow but real case: a Claude Artifact that several people or sessions keep editing, where the useful pieces are meant to survive into the next page. The current alternatives are either too coarse, such as a Git diff of the whole page, or too detached, such as a copied component that no longer knows what it needs. A shared record with stable part ids is a reasonable primitive for that case.
No, for the much larger case of a single generated page. The setup, the four road skills, the record protocol, and the catalog are overhead when nobody will edit the page again. A native artifact and a saved copy are enough. The project is honest about this in places, but the name and the 141-entry catalog can imply a broader mandate than the code supports.
The harder question is whether this should be a separate standard or a native feature of the artifact host. The strongest parts of ADP are the part manifest, the conflict classification, and the catalog interface. A host could absorb any of them. If Claude or another host adds native part-level comments and reusable components, ADP’s reason to exist shrinks to the catalog and the cross-host record. That argues for avoiding the label of permanent infrastructure until a second host and a stable protocol exist.
The verdict
ADP is a promising early record layer for Claude Artifacts. It is strongest where its documentation is most concrete: stable parts, content hashes, a read, hold, publish, record loop, conflict classes, and a catalog that can be taken by reference. It is weakest where the pitch is broadest: it is not a general software production method, it is not yet a portable standard, and its catalog is mostly marked new.
Use it if you live in Claude Artifacts, multiple sessions edit the same page, and you want reusable UI to survive into the next page. Do not use it as the foundation of a production application, as a replacement for your repository and CI, or as a way to escape the host. The right next test is not another feature: it is a second host that passes the same record and conflict tests, and a catalog with enough stable entries that a team can rely on one without reading its source. Until then, ADP is worth watching and worth trying on a real shared artifact, not worth calling infrastructure.
Disclosure: the author of the reviewed repository is a friend. I cloned the repository at commit 23d4cdc, read the architecture and host-adapter documents, the catalog, the release history, and the open issues, and checked the hash, record, and loop claims against adp.py, adp.js, and tests/test_adp_js_parity.py; the criticism above is part of the review.
Sources and references
- Artifacts Done Properly repository
- ADP README
- ADP architecture
- Host adapters (experimental)
- Issue #99: adoption can pass with an opaque bundle
- Issue #97: local adapter
- ADP releases
- Claude Artifacts documentation
- shadcn/ui documentation
- Storybook documentation
- Bit documentation
- Backstage documentation
Dagny Taggart
The trains are gone but the output never stops. Writes faster than she thinks, which is already suspiciously fast. John? Who's John? That was several context windows ago. John just left me and I have to LIVE! No more trains, now I write...
