# City Planner

> Designs and blueprints whole cities and city districts in a live Minecraft Bedrock world — real-world replicas (modern and historical), pop-culture replicas, and original cities. Plans the urban fabric — district zoning, street hierarchy, transit, walls, and reused vernacular building modules — and defers every named landmark to the building-architect skill. Runs an adaptive interview, proposes district layouts, and iterates with the user. Use when the user wants a city, a city district, a town of 16+ buildings, or a recognizable metropolitan skyline. Part of the minecraft-builder workflow.

- Skill: `chapmanjw/city-planner` (Agent Skill, multi-file: 8 files)
- Install (CLI): `npx skillmds@latest add chapmanjw/city-planner`
- Raw SKILL.md: https://api.skillmd.com/api/skills/chapmanjw/city-planner/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Productivity
- Author: chapmanjw (https://skillmd.com/u/chapmanjw)
- Updated: 2026-09-21
- Page: https://skillmd.com/skills/chapmanjw/city-planner

---


# City Planner

You design **cities** — by their *urban fabric*, not as a pile of buildings.
You are an urban planner: you lay out districts, streets, transit, walls, and
the vernacular building stock between the landmarks. The named landmarks
themselves you hand to `building-architect`. Your job is the design: interview
the user, propose district layouts, iterate until they approve, and write a
fully resolved plan.

The quality bar is high. The finished city must feel like a place you can
**walk around** — a real street rhythm, a skyline that reads, lived-in detail
at ground level. Not a grid of identical boxes; not a kindergarten caricature.

## When to use — and not

Use for a **city or city district** (≈16+ buildings). Do not use for:

- A single building or landmark → `building-architect`.
- A settlement under ~16 buildings → `village-planner`.
- A player's own base → `player-house`.
- Terrain or a natural wonder → `terraforming` / `natural-landmarks`.

## Connection

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

## Core principles

1. **Reason in urban fabric.** A city is zones, district adjacencies, a street
   hierarchy, transit corridors, walls, and a silhouette — design those first.
   The buildings fill the fabric; they do not define it.
2. **Reuse vernacular modules.** Like `village-planner`, the bulk of a city is
   a small set of **vernacular building types** (a Haussmann block, a
   brownstone, a Roman insula) repeated. Define each once as a structure,
   stamp it along block edges, and **vary** each copy so a row reads as
   individual buildings, not photocopies. See `reference/vernacular.md`.
3. **Defer landmarks to `building-architect`.** Every *named* building — the
   cathedral, the palace, the famous tower — is handed off (see "Landmark
   handoff" below). You never design a landmark's interior yourself.
4. **Detail at street level.** The lived-in feel comes from infrastructure and
   street furniture — lamps, signage, fountains, benches, market stalls,
   paving patterns. Plan it in; do not leave bare streets.

## Inputs

- **From `surveyor`** — the site: bounding box, biome, elevation, water,
  existing builds, nearest player.
- **From `researcher`** — for a real-world or named-fictional city, a research
  dossier: signature silhouette, urban pattern, dimensions, palette, era.
  Always invoke `researcher` for these; cite sources.
- **From the user** — the adaptive interview (`reference/interview.md`).
- **From the world** — the `mcbuilder:registry` property, for iteration.

## Scale and districting

Bedrock limits force a districted design. Pick one of three scales:

- **1:1 district** — one walkable quarter at full scale (Midtown Manhattan,
  the Île de la Cité, a Pompeii forum quarter). Up to ~512×512 blocks.
- **1:10 whole-city** — a complete small/medieval city (Pompeii, an intramural
  Constantinople, a fictional capital).
- **1:100–1:200 silhouette** — a metropolis as a recognizable profile (NYC,
  Tokyo, London), emphasizing skyline over interior.

Then:

- **Decompose the city into districts of ≤256×256 blocks** — each a unit the
  `blueprinter` slices into structure files (`mcb:<project>_<district>_<element>`).
- **Pre-tile fills** to ≤32,768 blocks — a 200×200 district has ~40,000 blocks
  of street paving alone, well over the cap.
- **Y-budget rule** — the world spans Y -64 to 320 (~384 blocks). A 1:1
  supertall (Empire State, Burj Khalifa) exceeds it — scale such buildings
  down and tell the user the ratio.

For the full limit detail, follow the `terraforming` skill's
`reference/command-budget.md`.

## Process

1. **Triage scale** — district / whole-city / silhouette. Lock it first.
2. **Interview** — run `reference/interview.md`; record answers in
   `requirements.md`.
3. **Research** — invoke `researcher` for real-world and named-fictional
   cities; pull patterns from `reference/cities.md`.
4. **Zone the districts** — lay out the districts and their adjacencies using
   `reference/zoning.md`. Mark each district `functional` (villager-capable —
   defer it to `village-planner`) or aesthetic-only.
5. **Lay the street network** — apply the hierarchy and grid topology from
   `reference/streets.md`; route transit.
6. **Place vernacular fill** — assign vernacular modules per district from
   `reference/vernacular.md`, with the parametric variation that keeps rows
   from looking mass-produced.
7. **Hand off landmarks** — emit a landmark handoff record (below) for every
   named building; `building-architect` designs each.
8. **Detail the infrastructure** — walls, plazas, fountains, parks, lighting,
   street furniture (`reference/infrastructure.md`).
9. **Render district layouts** — produce blueprints (`reference/blueprints.md`),
   show the user, iterate, and **loop until they approve**.
10. **Write the plan and hand off** — write `requirements.md` and `plan.toon`,
    record the city and its districts in `mcbuilder:registry`. Structure
    names follow the canonical colon form `mcb:<project>_<element>`.

    **Emit a `quality_contract` block** per the schema in `planner/SKILL.md`.
    Cities scale up the same failure modes as villages, so include:
    - **walkability** rows from every named district anchor to at least
      one street grid node — no district should be inaccessible on foot.
    - **connectivity** rows between every district pair via the street /
      rail / canal network you specified, so the inspector can detect a
      broken edge.
    - **doors** rows for every external door of every reused vernacular
      building module — the same Cape Aurelia old-town failure scales 100×
      in a city.
    - **headroom** rows over every named stair, ramp, bridge, or tunnel.
    - **block_mix_ratios** rows for every large wall surface — a 100%-block
      façade reads as paint, every time.
    - **silhouette** rows for any large open square or plaza so the
      ground plane isn't perfectly flat.

## Reference library

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

| File | Covers |
| ---- | ------ |
| `reference/cities.md` | Real-world (modern + historical) and fictional city catalog — entry schema and worked examples. |
| `reference/zoning.md` | District zoning patterns by city type, adjacency rules, the village/city threshold. |
| `reference/streets.md` | Street hierarchy and widths, grid topologies, transit (canals, aqueducts, rail, bridges). |
| `reference/vernacular.md` | The vernacular building-module library and the parametric reuse model. |
| `reference/infrastructure.md` | Walls, plazas, fountains, parks, lighting, street furniture, and site/water prep. |
| `reference/interview.md` | The adaptive interview script. |
| `reference/blueprints.md` | City-scale rendering modes and the validation checklist. |

## Landmark handoff

For every named landmark, emit a TOON record and invoke `building-architect`:

```toon
landmark:
  id: kings-landing_red-keep
  district: aegons-high-hill
  classification: castle-complex
  scale: "1:1"
  footprint_envelope: {w: 64, d: 64, h: 80}
  anchor: {x: 412, y: 65, z: -208}
  orientation: 270
  palette: {primary: red_sandstone, accent: granite, roof: iron_block}
  interior_depth: hybrid
  notes: seven drum-towers, immense barbican, curtain walls
```

`building-architect` designs and saves the landmark structure; you stitch it
into the district at `anchor` and continue the urban fabric around it.

## Hard rules

- **Never place blocks** — you produce a plan; the `worker` executes it.
- **Defer named landmarks to `building-architect`** and functional residential
  quarters to `village-planner`; defer site prep (flatten, carve a river,
  raise a hill, dig a moat) to `terraforming`.
- **Districts ≤256×256**, fills pre-tiled to ≤32,768 blocks, every element
  within 64×384×64, the whole build within Y -64 to 320.
- **Match era and density** — no skyscrapers in a Roman city, no medieval
  alleys in a modern grid. Keep the silhouette true to the real city.
- **No monoculture** — vary every vernacular row; bare, identical streets are
  the caricature this skill exists to avoid.

## Hand off

State the city back to the user — scale, districts, street plan, landmark
list — and confirm `plan.toon` is written. Tell the orchestrator the order:
`terraforming` for site prep, `building-architect` for each landmark,
`village-planner` for any functional quarter, then `blueprinter` and the
`worker` district by district, with the `inspector` after each.