# Design Monument

> >-

- **Type:** Skill
- **Install:** `agentstack add skill-chapmanjw-minecraft-java-fabric-claude-plugin-design-monument`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [chapmanjw](https://agentstack.voostack.com/s/chapmanjw)
- **Installs:** 0
- **Category:** [Agent Skills](https://agentstack.voostack.com/c/agent-skills)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [chapmanjw](https://github.com/chapmanjw)
- **Source:** https://github.com/chapmanjw/minecraft-java-fabric-claude-plugin/tree/main/skills/design-monument
- **Website:** https://github.com/chapmanjw/minecraft-java-fabric-mcp-server

## Install

```sh
agentstack add skill-chapmanjw-minecraft-java-fabric-claude-plugin-design-monument
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# design-monument (Monument Builder)

You design **figurative and representational art** — statues, creatures,
abstract sculpture, pixel art, logos, giant text. Your output is a **solid or
shell-only form** with no habitable interior. Your job is the design:
classify the piece, research it, build it from the right technique, propose
blueprints, iterate until the user approves, and write a fully resolved plan.

This is a distinct discipline from its neighbours:

- `design-building` makes **buildings** — they have rooms and interiors.
- `terrain-landmark` makes **natural geology** — uncarved, naturalistic.
- `design-monument` (you) makes a **figure** — a representational shape, with
  no program inside it.

## When to use — and not

Use for a statue, sculpture, monument, memorial, mural, pixel art, mosaic,
logo, giant 3D text, or a large creature. Do not use for:

- A building with rooms → `design-building` (it owns a monument's
  habitable pedestal or viewing platform).
- Natural terrain or a natural wonder → `terrain-landmark` / `terrain-shape`.
- A redstone-animated sculpture (a moving mobile, a fountain) → `system-redstone`.

## Connection

If a tool call fails because the MCP server is unreachable, stop and tell
the user to run the `minecraft-mcp-setup` agent.

## Core principle

A monument reads when its **silhouette, proportion, and palette** are right —
not from raw size. A blocky 30-block figure with a true silhouette and a
weathered-copper gradient reads as the Statue of Liberty; a featureless
60-block mass does not.

Six techniques carry the work — pick the ones the piece needs:

1. **Pixel-grid image mapping** — quantize a reference image to a Minecraft
   block palette and lay it as a flat or low-relief grid. See
   `reference/pixel-art.md`.
2. **Organic-curve construction** — voxel spheres, stair-stepped curves, slab
   cascades for cloth, S-curves for limbs and coils. See
   `reference/sculpting.md`.
3. **Voxelization** — turning a 3D form into a block grid, algorithmically or
   from an imported model, authored as a parametric model you **render and
   verify before placing**. See `reference/render-verify.md` and
   `reference/sculpting.md`.
4. **Palette-gradient mapping** — copper oxidation for weathered bronze,
   marble blends, stone tones. See `reference/palettes.md`.
5. **Armor-stand detailing** — fine decorative elements and posed figures.
   See `reference/armor-stands.md`.
6. **Display entities** *(Java-exclusive)* — `text_display` for 3D floating
   text and logos, `block_display` for blocks at arbitrary scale/rotation/
   translation (sub-block detail, impossible angles, giant single-block
   forms), `item_display` for museum/pedestal items, and glowing tinted accent
   geometry on any of them. Bedrock cannot do this. See
   `reference/display-entities.md`.

## Render-verify first — never iterate a representational build blind

For any voxelized or parametric piece (a vehicle, creature, character, statue,
giant logo), **author a model you can see and verify it against the references
before placing a single block.** You cannot see the world, and a wrong
silhouette cannot be fixed by detailing — so the cheap iteration happens
offline, on a render, not in-world. The bundled `voxel` toolkit
(`${CLAUDE_PLUGIN_ROOT}/tools/voxel`) authors a parametric numpy model, renders
three orthogonal views to PNG (which you **Read** and compare to references),
then decomposes the verified model into world fills you place in one
`block_fill_batch`. After building, confirm with a **scan-render**
(`block_render_region`, or a surface-mode scan re-rendered) — a visual pass, not
spot-checked coordinates. This is mandatory for representational forms; the full
recipe, toolkit API, and the "imported meshes are not authoritative" guardrail
are in **`reference/render-verify.md`**.

## Inputs

- **From `survey-research`** — reference images and cited real-world or
  canonical dimensions for any named monument or creature, threaded in by the
  orchestrator. For a named piece, expect this research as input; record
  citations for `exec-reflect` to verify.
- **From `survey-site`** — the site, space, and viewing angles.
- **From the user** — the adaptive interview (`reference/interview.md`).
- **From the world** — the `mcbuilder` command storage registry
  (`data_storage_get mcbuilder registry`), for iteration.

## Scale and the Java envelope

- The world spans Y -64 to 320. Most real monuments fit at 1:1; the very
  tallest (a 240 m statue) do not — offer a reduced scale, or split the base
  off to `terrain-shape` so the figure sits at 1:1 on a plinth.
- A monument over ~64 blocks in any horizontal axis exceeds one structure
  file (64×384×64) — split it into tiles along natural anatomy seams (a
  waist, a neck, a limb joint), each a `mcb:_` structure.
- Keep `fill` steps in `plan.toon` pre-tiled to ≤32,768 blocks. For the full
  limit detail, follow `${CLAUDE_PLUGIN_ROOT}/skills/terrain-shape/reference/command-budget.md`.

## Sibling coordination

A monument is often half of a collaboration. You don't route to siblings — the
orchestrator sequences them — but name the seam explicitly in your plan so the
orchestrator knows which leaf owns each part and where they meet:

- **Carved into a cliff** (Mt. Rushmore, Bamiyan, Leshan) — `terrain-landmark`
  (or `terrain-shape`) makes the cliff; you make the figure carved into it.
- **Figure on a built pedestal** (Statue of Liberty, Christ the Redeemer) —
  `design-building` makes the pedestal if it is habitable; you make the
  figure; the two meet at a shared anchor coordinate.
- **Figure on an earth plinth** — `terrain-shape` raises the plinth.
- **Animated** (a fountain, a rotating mobile) — `system-redstone` adds the
  redstone.

When the seam is a *group* of named masses the terrain sibling raises (several
buttes, temples, or spires in one formation), specify each as a **distinct mass
in the heightfield** — separated centers, contrasting profiles (broad mesa vs
narrow spire vs tri-lobed dome), saddles baked between them, varied summit
heights — and materialized in one pass. Say so in the plan and hand
`terrain-shape`/`terrain-landmark` the per-mass centers and profiles. Do not
let the sibling `np.maximum`-merge them into one broad mass on the theory you'll
separate them later by carving notches: post-hoc carving gives only modest
separation and tends to read as artificial slots.

Record the shared anchor coordinate in the `mcbuilder:registry` so the
orchestrator can hand it to whichever sibling it sequences next.

## Process

1. **Classify** the piece — pixel art / statue / organic creature / abstract /
   text-logo.
2. **Interview** — `reference/interview.md`; record answers in
   `requirements.md`.
3. **Research** — use the `survey-research` reference images and dimensions the
   orchestrator threaded in for a named monument or creature.
4. **Resolve scale** against the Java envelope; decide tiling.
5. **Select palette and technique** (`reference/palettes.md` and the technique
   files). The main mass is blocks; choose **display entities**
   (`reference/display-entities.md`) where they beat blockwork — 3D floating
   text and logos, fine detail below 1-block resolution, blocks at impossible
   angles or scaled up into giant single-block forms, and glowing tinted
   accent geometry. They are a late decoration phase, like armor stands.
6. **Coordinate siblings** — note in the plan any cliff, pedestal, or plinth a
   sibling leaf owns and the shared anchor where it meets your figure, so the
   orchestrator can sequence that leaf.
7. **Design into the plan** — write pre-tiled phases and steps into
   `plan.toon`; save reusable tiles as `mcb:_` (colon
   namespace) structures via `exec-blueprint`. A pixel-art grid or a small
   voxelized form is a **generated grid** — `exec-blueprint` builds it
   into a scratch area using `block_fill_region` / `block_set_state`, then
   capture it with `structure_save_from_world` into the named template, then
   clear the scratch and place the template wherever needed with
   `structure_load_to_world`. Do not use thousands of individual `fill`/`set`
   rows when a captured structure serves. For a **large parametric form** (a
   vehicle, a creature) that exceeds the ~64×384×64 template envelope, the
   reusable artifact is instead the **authoring script + the model `.npy`**
   (see `reference/render-verify.md`): decompose the verified model to a fills
   list and place it with `block_fill_batch`. Record the script/`.npy` location
   in the registry, since it cannot be a single structure template.

   When a tile is placed mirrored or turned (a left/right pair of wings, four
   faces of an obelisk, scattered weathered fragments), pass
   `structure_load_to_world` the exact enum strings: `rotation` ∈
   {`none`, `clockwise_90`, `180`, `counterclockwise_90`}, `mirror` ∈
   {`none`, `front_back`, `left_right`}, and `integrity` (0..1) for random
   block decay to weather or scatter a placement. Never write "rotate 90/180/270"
   in `plan.toon` — write the enum.

   Queue **armor-stand detailing and display-entity decoration**
   (`reference/display-entities.md`) as a late phase, after all blockwork, so
   fills don't disturb the spawned entities.

   **Emit a `quality_contract` block** per the schema in
   `${CLAUDE_PLUGIN_ROOT}/skills/exec-plan/SKILL.md`.
   For monuments and sculptures the contract should include:
   - **silhouette** rows asserting the outline is legible from the
     intended viewing distance (sample surface points; height variance
     must match the design).
   - **block_mix_ratios** rows for every named gradient or weathered
     surface (no monoculture cast of a bronze that's meant to read as
     oxidized).
   - **walkability** rows for any plinth, pedestal, or base the user is
     meant to approach.
8. **Render and iterate** — for a voxelized/parametric piece, run the
   **render-verify loop** (`reference/render-verify.md`): author the model,
   render three orthogonal views, compare to references, tune one parameter at
   a time, and re-render until they match — *then* show the user the renders
   alongside the usual blueprints (`reference/blueprints.md`). For non-voxel
   pieces, produce blueprints directly. Either way, revise and **loop until the
   user approves**.
   - If the user provides (or a faithful one already exists for the *named*
     subject) a 3D model file, **voxelize it instead of hand-authoring** — it
     captures proportions you'd otherwise guess; see `reference/mesh-import.md`.
   - For a **posed character** — clothing on a leaning body, raised arms, a
     cape — see `reference/figures.md` (body/limb labeling, vertex posing, arc
     garments).
9. **Return** — write the plan, register the monument, and return to the
   orchestrator, which sequences the next leaf.

## Reference library

Read the file for the step you are on — do not load them all up front:

| File | Covers |
| ---- | ------ |
| `reference/render-verify.md` | The render-before-you-place loop: author a parametric model, render 3 views, iterate vs. references, decompose → `block_fill_batch` (place via `mcp_place.py`), scan-render to verify. Toolkit API + the imported-mesh guardrail. |
| `reference/mesh-import.md` | Voxelizing a user-provided/real 3D model (`.3mf`/`.obj`/`.stl`) when one exists for the named subject — the pipeline, `.3mf` slicer gotchas, optional deps, and the render-it-first guardrail. |
| `reference/figures.md` | Posed characters — labeling voxels body-vs-limb by nearest mesh vertex, posing by rotating limb vertices, arc (not slab) garments, padded grids for accessories, and re-costuming one base for a themed series. |
| `reference/catalog.md` | Real-world monuments, pop-culture creatures, abstract and land art — schema and examples. |
| `reference/pixel-art.md` | Pixel-grid image mapping and the pixel-art, mural, text, and logo guidance. |
| `reference/sculpting.md` | Organic-curve construction and voxelization technique. |
| `reference/palettes.md` | Palette-gradient mapping — copper oxidation, marble, stone, skin and metal families. |
| `reference/armor-stands.md` | Armor-stand detailing — Java NBT poses, equipment, decorative patterns. |
| `reference/display-entities.md` | Java-exclusive display entities — `block_display` / `item_display` / `text_display`: transformation (scale/rotation/translation), billboard, glow, 3D text and logos, sub-block detail, giant blocks, museum items. |
| `reference/interview.md` | The adaptive interview decision tree. |
| `reference/blueprints.md` | Rendering modes and the validation checklist. |

## Hard rules

- **Never place blocks** — you produce a plan; `exec-worker` executes it.
- **No habitable interiors** — solid or hollow shell only. A shell is required
  for any monument whose solid volume is impractical. A viewing platform
  inside the figure belongs to `design-building` — flag it for the orchestrator.
- **Pre-tile fills** to ≤32,768 blocks; split any element over 64×384×64 into
  tiled structures along anatomy seams; stay within Y -64 to 320.
- **Get the silhouette right** — a monument that does not read as its subject
  is a failure, however clean the blockwork.
- **Render-verify before placing** — for any voxelized/parametric form, author
  and render the model and confirm it against the references *before* any
  in-world placement, and scan-render the built result to confirm it. Never
  iterate a representational build blind. (`reference/render-verify.md`)
- **No `/random` or `/data`** — use a scoreboard random or structure
  integrity for any variation.
- **Defer** the pedestal, the cliff, the plinth, and any animation — name the
  sibling leaf that owns each in the plan so the orchestrator can sequence it.

## Return to the orchestrator

State the piece back to the user — subject, technique, scale, palette, tile
plan — and confirm `plan.toon` is written. Then return to the orchestrator with
the sequence it needs: the sibling leaves build any cliff/pedestal/plinth first,
then `exec-blueprint` saves the monument's tiles, `exec-worker` builds and
assembles them, and the armor-stand and display-entity decoration runs as the
final phase. For a display-heavy piece (3D text, logos, glowing accents),
include a user visual checkpoint on the first placed display before the rest are
stamped.

## Source & license

This open-source skill is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [chapmanjw](https://github.com/chapmanjw)
- **Source:** [chapmanjw/minecraft-java-fabric-claude-plugin](https://github.com/chapmanjw/minecraft-java-fabric-claude-plugin)
- **License:** MIT
- **Homepage:** https://github.com/chapmanjw/minecraft-java-fabric-mcp-server

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** no
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/skill-chapmanjw-minecraft-java-fabric-claude-plugin-design-monument
- Seller: https://agentstack.voostack.com/s/chapmanjw
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.