Skip to main content
plugin CX Codex

lvtd-skills — Claude Code and Codex plugin: agent skills catalog

lvtd-skills is a plugin for Claude Code and Codex with ready-made agent skills for Django, htmx, Rust, developer docs, SEO, traction and nonfiction books, one SKILL.md per topic.

MIT ★ 1,596 updated 2026-10-29

Install into Claude Code · Plugin marketplace All methods and platforms ↓
/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install lvtd-skills@awesome-codex-plugins
Open on GitHub

What lvtd-skills does

Each skill is its own folder with a SKILL.md file, and the agent reads those files straight from disk. Coverage goes from Django and htmx (server-rendered partials, background jobs, faster test suites) to Rust services and small 2D games, plus developer documentation, SEO planning, customer interviews and startup traction. Two utilities sit at the edge: cookiecutter for project templates and calibredb for a Calibre library.

When the right skill is not obvious, lvtd-skills-router sorts the task by domain and hands the agent the smallest useful set. Validation and marketplace-manifest scripts live beside the catalog, and npm run build regenerates the Astro site from the same source files.

The repository is archived and the author has stopped working on it. Installing still works, reading the skills still works. What you will not get is a fix when Django, htmx or Rust move past the recipes inside a SKILL.md, so check them against your own versions.

What it helps with

  • add server-rendered partial updates to a Django app
  • run black-box HTTP integration tests against a Rust service
  • sequence SEO work into a roadmap
  • shape a nonfiction book's table of contents around reader outcome
  • pick traction channels and cheap experiments

Example prompts for the agent

  • Use lvtd-skills-router to find which skill covers background jobs in Django.
  • Write black-box HTTP integration tests for my Rust service.
  • Sequence my SEO work into a roadmap.

How to install lvtd-skills

Plugin marketplace

/plugin marketplace add hashgraph-online/awesome-codex-plugins
/plugin install lvtd-skills@awesome-codex-plugins

Step by step, with commands for each platform: Claude Code plugins: marketplaces, installing, and building your own

Questions about lvtd-skills

How do I install lvtd-skills in Claude Code?

From the marketplace: run /plugin marketplace add hashgraph-online/awesome-codex-plugins, then /plugin install lvtd-skills@awesome-codex-plugins.

What does lvtd-skills do?

It brings a folder-per-skill collection into your agent's reach: Django and htmx, Rust, documentation, SEO, customer discovery, traction, book writing, plus cookiecutter and calibredb. The agent opens the relevant SKILL.md and follows it.

Is the collection still maintained?

No. The repository is archived and the author no longer updates it, so the skills stay as a historical reference.

Source text

skills · MIT
> [!NOTE]
> **This repository is archived and is no longer maintained.** The skills in this collection are no longer relevant to my current workflows, and I am changing my approach to creating, organizing, and maintaining skills. The repository remains available for historical reference.

<img src="assets/app-icon.png" alt="LVTD fire heart logo" width="96" height="96">

# LVTD Skills

Reusable agent skills for LVTD projects, Django SaaS workflows, and agent-first software development.

This repository is intentionally simple: every skill lives in `skills/<skill-name>/SKILL.md`, with small validation and publishing scripts around that catalog. That shape works well for agents that read skill folders directly, and it is easy for external indexes like skills.sh to consume.

## Common Workflows

Start with [`lvtd-skills-router`](skills/lvtd-skills-router/SKILL.md) when you
are not sure which skill fits. It routes by domain and desired outcome, then
points the agent at the smallest useful set of skills.

- **Django SaaS work**: use `django-htmx` for server-rendered partial updates,
  `alpinejs-django` for local template behavior, `django-q2` for background
  jobs, `fastmcp-django` for MCP servers inside Django apps, and the
  `django-test-*` skills when test suites need profiling, faster data setup,
  parallelism, or CI optimization.
- **Framework-neutral htmx work**: use `htmx-foundations` for architecture and
  first workflows, `htmx-endpoint-design` for request/fragment contracts,
  `htmx-recipes` for common interaction patterns, `htmx-security` for XSS,
  CSP, CSRF, and sanitization, `htmx-realtime` for polling/SSE/WebSockets,
  `htmx-interactivity` for Alpine.js or `_hyperscript` coordination, and
  `htmx-js-api` for imperative htmx integrations.
- **Developer documentation**: use `developer-docs-technical-research` before
  writing from incomplete product facts, `developer-docs-planning` and
  `developer-docs-drafting` for doc plans and pages, `saas-documentation` for
  hosted-service docs and runbooks, `documentation-platform-selection` for docs
  tooling decisions, and `docs-agile-integration` for sprint and release
  process integration.
- **Rust service and game work**: use `rust-api-test-harness` for black-box HTTP
  integration tests, then reach for the Rust service skills when the work
  involves SQLx/Postgres, domain boundaries, observability, security,
  idempotent workflows, or deployment readiness. For language-level Rust work,
  use the ownership, trait API, iterator/collection, concurrency, async, unsafe,
  and FFI skills. For small Rust games, use the game-slice, game-loop, tilemap,
  ECS, turn-intent, procgen/AI, data-driven content, and release-polish skills.
- **SEO and organic growth**: use `seo-opportunity-research` to find demand,
  `seo-persona-intent-mapping` to clarify audience and intent,
  `product-led-seo-strategy` to shape the strategy, `seo-roadmap-prioritization`
  to sequence work, and `technical-seo-triage` for indexing or traffic issues.
- **Useful nonfiction books**: use `book-toc-lab` to shape the promise, scope,
  reader outcome, and takeaway-first table of contents; use
  `book-reader-conversations` for pre-draft validation,
  `technical-book-lab-design`, `technical-manuscript-verification`, and
  `evergreen-technical-book` for practical technical books, and
  `manuscript-engagement-analytics` plus the other nonfiction skills for reader
  experience edits, beta feedback, seed marketing, sales optimization, and
  self-publishing production.
- **Customer discovery**: use `customer-discovery-conversations` to plan
  better customer conversations, then use the related skills for segment
  slicing, conversation access, commitment validation, and notes synthesis.
- **Startup traction**: use the traction skills to choose channels, research
  comparable growth paths, design cheap tests, review results, and plan
  channel-specific experiments.
- **Product and launch polish**: use `make-product-viral` to improve clarity,
  memorability, buying intent, and shareability on product-facing surfaces.
- **Catalog and template operations**: use `calibredb` for Calibre library
  operations and `cookiecutter` for template authoring, hooks, and generated
  project validation.

## Skill Discovery

Use [`lvtd-skills-router`](skills/lvtd-skills-router/SKILL.md) when you are not
sure which skill fits. The complete catalog lives in `skills/` and the generated
registry; this README intentionally groups workflows instead of mirroring every
skill file.

Skill areas:

- **Django**: server-rendered UI, HTMX, Alpine.js, background jobs, MCP servers,
  and Django test-suite optimization.
- **htmx**: foundations, endpoint contracts, common interaction recipes,
  local interactivity coordination, JavaScript API integration, realtime
  transports, and security hardening for server-driven web apps.
- **Developer documentation**: audience research, technical research, planning,
  drafting, editing, code samples, visuals, SaaS docs, Agile integration,
  platform selection, feedback triage, metrics, information architecture,
  release, and maintenance.
- **Rust**: HTTP API test harnesses, SQLx/Postgres persistence, domain
  boundaries, observability, security, idempotent workflows, deployment,
  ownership/borrowing, trait API design, iterators/collections, concurrency,
  async tasks, unsafe boundaries, FFI wrappers, and 2D game development
  workflows for planning, loops, tilemaps, ECS, turns, procgen, content, and
  release.
- **SEO**: opportunity research, persona-intent mapping, product-led strategy,
  roadmap prioritization, and technical SEO triage.
- **Nonfiction writing**: table-of-contents design, reader experience editing,
  beta feedback, seed marketing, sales optimization, and production.
- **Customer discovery**: customer interview planning, segment slicing,
  conversation access, commitment validation, and learning synthesis.
- **Traction**: Bullseye channel selection, channel research, cheap tests,
  experiment reviews, and channel-specific playbooks.
- **Utilities**: Cookiecutter template development, Calibre library operations,
  and product/launch polish.

## Repository Layout

```text
CONTEXT.md
skills/
  <skill-name>/
    SKILL.md
docs/
  installation.md
scripts/
  build-marketplaces.mjs
  build-registry.mjs
  skill-utils.mjs
  validate-marketplaces.mjs
  validate-skills.mjs
src/
  pages/
    index.astro
    catalog.json.js
```

## Catalog Site

The public catalog site is an Astro static site generated from the same canonical
repo data as the registries and marketplace manifests:

- `skills/<skill-name>/SKILL.md`
- `scripts/skill-utils.mjs`
- `scripts/marketplace-utils.mjs`
- generated marketplace plugin groupings

Run the full repository build to validate skills, refresh marketplace artifacts,
and generate the site:

```bash
npm run build
```

The Astro output goes to `site-dist/`. The generated JSON endpoint is available
at `/catalog.json`, and skill/plugin pages are generated at build time.

## Install A Skill Directly

Use the `skills` CLI to install from this repository:

```bash
npx skills add LVTD-LLC/skills --skill django-htmx
```

Common targets:

```bash
# Codex global skills
npx skills add LVTD-LLC/skills --skill django-htmx -g -a codex

# Claude Code global skills
npx skills add LVTD-LLC/skills --skill django-htmx -g -a claude-code

# OpenClaw global skills
npx skills add LVTD-LLC/skills --skill django-htmx -g -a openclaw

# Install from a local checkout
npx skills add . --skill django-htmx
```

More details are in [`docs/installation.md`](docs/installation.md).

## Marketplace Install

Add the marketplace in Claude Code:

```text
/plugin marketplace add LVTD-LLC/skills
/plugin install router@lvtd-skills
/plugin install django@lvtd-skills
/reload-plugins
```

Claude Code exposes the router as `/router:lvtd-skills-router`. Domain plugins
expose bundled skills such as `/django:django-htmx`, `/django:django-q2`, and
the other skills in each plugin.

Add the marketplace in Codex:

```bash
codex plugin marketplace add LVTD-LLC/skills
codex plugin add router@lvtd-skills
codex plugin add django@lvtd-skills
```

Codex exposes the router as `$router:lvtd-skills-router`. Domain plugins expose
bundled skills such as `$django:django-htmx`, `$django:django-q2`, and the other
skills in each plugin.

To pick up a marketplace update for an already-installed Codex plugin, refresh
the marketplace snapshot and reinstall the plugin:

```bash
codex plugin marketplace upgrade lvtd-skills
codex plugin remove django@lvtd-skills
codex plugin add django@lvtd-skills
```

This repository ships the marketplace files directly:

```text
.claude-plugin/marketplace.json
.agents/plugins/marketplace.json
plugins/<plugin-name>/
```

The plugin skill folders are generated copies of `skills/<skill-name>/`, so
Git-backed marketplace installs have real `SKILL.md` files while the canonical
source remains under `skills/`. Do not edit generated plugin copies directly.

Refresh generated marketplace artifacts during development:

```bash
npm run build
```

Generated marketplace plugin IDs:

- `b2b-sales`
- `cookiecutter`
- `customer-discovery`
- `developer-docs`
- `django`
- `eighty-twenty`
- `game-design`
- `game-geometry`
- `linkedin-writing`
- `nonfiction-book-writing`
- `router`
- `rust-core`
- `rust-game-development`
- `seo`
- `traction`
- `web-design-math`

Marketplace plugins group related skills. Direct installs through the `skills`
CLI still use the canonical skill directory names.

## Marketplace Strategy

See [`docs/marketplace-strategy.md`](docs/marketplace-strategy.md) for the
research-backed plan to publish this catalog across Codex, Claude Code,
OpenClaw, and other Agent Skills-compatible clients.

## Attribution

This catalog is built from transformed, task-oriented guidance rather than
copied source text. Book-derived skills paraphrase operational ideas, keep
source traceability in the relevant skill files where useful, and are not
official material from the authors, libraries, tools, or platforms below.

Primary books and long-form sources:

- *Docs for Developers: An Engineer's Field Guide to Technical Writing* by
  Jared Bhatti, Zachary Sarah Corleissen, Jen Lambourne, David Nunez, and Heidi
  Waterhouse: developer documentation audience research, planning, drafting,
  editing, feedback, quality measurement, publishing, maintenance, and
  information architecture.
- *The Product Is Docs: Writing Technical Documentation in a Product Development
  Group* by Christopher Gales and the Splunk Documentation Team: documentation
  in product teams, Agile integration, technical research, technical
  verification, customer feedback, support and field collaboration, SaaS
  documentation, docs tooling, maintenance, quality metrics, and platform
  selection.
- *The Mom Test* by Rob Fitzpatrick: customer discovery conversations, segment
  slicing, conversation access, commitment validation, and learning notes.
- *Write Useful Books* by Rob Fitzpatrick: useful nonfiction book planning,
  reader experience, beta feedback, seed marketing, sales optimization, and
  self-publishing production patterns.
- *Traction: How Any Startup Can Achieve Explosive Customer Growth* by Gabriel
  Weinberg and Justin Mares: Bullseye channel selection, traction goals,
  cheap channel tests, review workflows, and channel-specific playbooks.
- *80/20 Sales and Marketing* by Perry Marshall: power-law analysis, market
  selection, traffic strategy, conversion messaging, funnel economics,
  USP/guarantee work, customer value, and time/team leverage.
- *Product-Led SEO* by Eli Schwartz: product-led SEO strategy, opportunity
  research, persona-intent mapping, roadmap prioritization, and technical SEO
  triage.
- *Ultimate Guide to Link Building* by Garrett French and Eric Ward:
  link-building strategy, linkable assets, prospecting, prospect
  qualification, outreach, broken link building, guest posts, and local
  sponsorship link building.
- *Growth Hacking LinkedIn* by Bjorn Radde: LinkedIn post writing, content
  ideation, comment writing, article/newsletter writing, and post
  experimentation patterns.
- *Zero to Production in Rust* by Luca Palmieri: Rust HTTP API testing,
  SQLx/Postgres service boundaries, deployable service patterns, security,
  observability, domain boundaries, and idempotent workflows.
- *Programming Rust* by Jim Blandy, Jason Orendorff, and Leonora F. S. Tindall:
  Rust ownership/borrowing, traits, iterators/collections, concurrency,
  async task design, unsafe boundaries, and FFI wrappers.
- *Hands-On Rust* by Herbert Wolverson: Rust game slice planning, bracket-lib
  game loops, tile maps and cameras, ECS gameplay, turn/intent systems,
  roguelike procedural generation and AI, data-driven content, and release
  polish.

Short-form sources and public posts:

- Marc Lou's ["32 Principles of a Viral Product"](https://x.com/marclou/status/2065385672991752210)
  post on X inspired `make-product-viral`.

Libraries, tools, and official documentation referenced while authoring skills:

- Agent Skills documentation and best practices, Claude Code skills/plugins and
  plugin marketplace docs, OpenAI Codex plugin docs, OpenClaw skills/plugins
  docs, and the `skills` CLI.
- Django, HTMX, `django-htmx`, Alpine.js, `django-q2`, FastMCP, Cookiecutter,
  Calibre/`calibredb`, pytest-style Django testing, and related Python web
  tooling.
- Rust ecosystem libraries and tools used in guidance and examples, including
  Actix, Axum, Tokio, SQLx, PostgreSQL, Docker, `tracing`, `thiserror`,
  `anyhow`, `wiremock`, Cargo verification workflows, `bracket-lib`, Legion,
  Bevy ECS, Serde, and RON.

Skill authoring and review resources:

- Project-installed helper skills: `ebook-analysis`, `skill-from-book`,
  `skill-creator`, `write-a-skill`, and `pdf`.
- Compound Engineering plugin workflows, including work execution, session
  history, review, and shipping guidance.
- Superpowers plugin workflows for planning, execution, verification, and
  branch-finishing discipline.
- Greptile review feedback and the HOL Plugin Scanner were used as review and
  validation inputs on parts of the catalog.

## Development

New skills should follow [`docs/adding-skills.md`](docs/adding-skills.md).

Validate source skills only:

```bash
npm run validate
```

Build the machine-readable registry and refresh committed marketplace artifacts:

```bash
npm run build
```

The registry is written to `dist/registry.json`. Marketplace artifacts are
written to `.claude-plugin/`, `.agents/plugins/`, and `plugins/`.

Validate generated marketplace artifacts:

```bash
npm run validate:marketplaces
```

Run the full local/CI check before opening a PR:

```bash
npm run check
```

## Publishing

CI validates every push and pull request. Publishing is tag-driven:

1. Update the catalog version in `package.json`.
2. Run `npm run check` and commit the generated marketplace artifacts.
3. Create and push a matching `v*` tag, for example `v0.1.3`.

The catalog version in `package.json` is also the generated marketplace plugin
version, so Codex installs use a new plugin cache path when the version changes.
The `Publish` workflow packages the registry and marketplace tarballs, then
publishes them on the GitHub release for pushed `v*` tags.

© LVTD · MIT · hashgraph-online/awesome-codex-plugins

Similar plugins

All plugins for Agent setup: memory, context, orchestration →

From the same set391

The whole set →
mcp-md-reader The mcp-md-reader plugin lets an agent navigate Markdown structure and fetch only the needed section. It fits large files and linked note vaults. CX Codex ★ 1,596repo stars mailagent mailagent hands the agent throwaway inboxes so it can read verification codes and magic links, finish a signup check, then clean up. CX Codex ★ 1,596repo stars magents magents connects Codex, Claude, and Cursor through a shared MCP session bus. Useful when handing off context or spawning tasks across tools without copy-pasting. CX Codex ★ 1,596repo stars maestro maestro sends a prompt to several local model CLIs, then has a judge compare their answers and a synthesizer produce a grounded result. Use it when you want one considered response from a model panel. CX Codex ★ 1,596repo stars krypton krypton is a Claude Code and Codex plugin that turns development requests into plans with owners, cutover decisions, and acceptance evidence. Use it for feature work, bug fixes, refactors, migrations, and architecture goals. CX Codex ★ 1,596repo stars kernel kernel is a plugin for Claude Code and Codex that uses hooks to block destructive commands and gate irreversible steps with a one-time token. CX Codex ★ 1,596repo stars jev-use jev-use offloads non-text decisions and shell execution checks to the Jev judgment model to cut token usage. CX Codex ★ 1,596repo stars sirv-media-skills sirv-media-skills is a Claude Code and Codex plugin with eight skills for auditing images and video, Sirv APIs, galleries, 360 spins, and media performance. CX Codex ★ 1,596repo stars

Project sponsors

Companies that keep this analytics open