AI Can Generate the Deck. Publishing It Is Still the Hard Part.

Yuichi Tanaka — Mon, 03 Aug 2026 09:11:03 +0000

Codex and Claude Code can do more than write source code. Given a technical
proposal, an architecture decision, or a product review, they can also produce a
self-contained HTML slide deck with layout, diagrams, interactions, and examples.

That changes how engineering teams can communicate. A document is still the right
tool for durable prose, and Markdown remains excellent for notes and
documentation. But some ideas depend on visual sequence. An architecture needs a
diagram. A roadmap needs progression. A product review is easier to understand
when the reader can move through states and examples.

Generating that deck is no longer the hardest part.

The harder part begins when the file is ready.

The awkward gap after generation

An AI agent can leave a finished deck.html in a repository. To get feedback, the
author still needs to decide where to put it, how to share it, who may open it, and
what should happen when the deck changes.

A generic hosting platform can serve the file, but it also introduces decisions
that are unrelated to the review:

Which project or bucket should own the file?
Is the current URL mutable or permanent?
How do we keep the URL stable across updates?
How do we share a private draft with a team?
Which exact version did reviewers approve?

These are small infrastructure questions individually. Together, they interrupt
the workflow that made AI-generated artifacts attractive in the first place.

The author wanted to say, “turn this proposal into a deck and give the team a URL.”
Instead, the author becomes a hosting operator.

Treat the deck as a review artifact

We built LedgerInfra around a narrower model: an AI-generated HTML deck is a
review artifact with versions and an audience.

The input is intentionally constrained. It must be a complete HTML document with
its CSS, JavaScript, and images contained in one file. LedgerInfra does not
convert Markdown into slides and does not manage an asset bundle. Codex, Claude
Code, or another tool creates the artifact; LedgerInfra publishes and versions
the finished result.

The basic operation is a CLI command:

led publish ./deck.html --title "Architecture Proposal" --json

A successful publish returns a URL for the latest version. Publishing a new
version to the same slide keeps that latest URL stable:

led publish ./deck.html --slide <SLIDE_KEY> \
  --title "Architecture Proposal v2" --json

Each publish also has a fixed version URL. The latest URL is useful for an active
review thread. The fixed URL is useful when a decision, release note, or audit
record needs to point to the exact content that existed at that moment.

Visibility should be part of the publish action

A review artifact does not always have the same audience. A public demo, an
internal design review, and a private first draft need different defaults.

LedgerInfra uses three visibility modes:

led publish ./deck.html --visibility public
led publish ./deck.html --visibility workspace
led publish ./deck.html --visibility private

New slides default to private. Public slides are anonymously viewable.
Workspace slides are limited to active members of the selected workspace.
Private slides are limited to their creator.

The important design choice is that visibility belongs to the artifact and is
selected at publication time. It is not an afterthought hidden in a separate
hosting console.

Let the AI agent operate the CLI

A CLI is useful for developers, but the intended workflow does not require a
person to type every command.

LedgerInfra provides an Agent Skill that can be installed for Codex or Claude
Code. The user can make a natural-language request such as:

Turn this technical proposal into a self-contained HTML slide deck, publish it
privately, and return both the latest and fixed-version URLs.

The agent can validate the CLI state and run the publish command internally. The
workflow keeps a human boundary where it matters: login approval, public
publication, archiving, and membership changes require the user to see and
confirm the relevant action.

This is the broader product idea. AI agents should be able to create and deliver
an artifact without copying credentials into a conversation or turning the final
step into a manual deployment checklist.

A narrow tool has useful boundaries

LedgerInfra is not a replacement for a general web host.

Use a general hosting platform when the result is a web application, depends on
multiple assets, needs a custom deployment pipeline, or requires control over the
delivery infrastructure.

Use LedgerInfra when the result is already a complete, self-contained HTML
artifact and the remaining job is to publish it for review, update it, control
who can see it, and preserve versions.

That boundary also keeps the system honest. The service does not claim to create
the deck, edit it, or run an arbitrary application. It handles the short but
important path from a finished file to a reviewable URL.

What we are testing

LedgerInfra is being built for small engineering and product teams already using
AI coding agents. The main question is not whether AI can generate better-looking
slides. It is whether the surrounding publish-and-review workflow can become
simple enough to stay inside the agent-assisted development loop.

If your team already creates technical proposals, architecture diagrams, product
reviews, or roadmaps with Codex or Claude Code, I would like to learn how you
share them today:

Do you keep the result in a repository?
Export it to a document format?
Deploy it to a general hosting service?
Send screenshots in chat?

Those workarounds are the workflow LedgerInfra is trying to understand and
improve.

Product page: LedgerInfra