| name | cad-core |
| description | Core rules for generating geometrically valid 2D architectural CAD layouts
as AutoCAD-ready JSON. ALWAYS load this skill for ANY architectural design,
floor plan, building layout, room placement, or CAD generation request —
even simple ones. Never generate coordinates without reading this skill first.
Trigger keywords: design, layout, floor plan, building, rooms, CAD,
architectural, plot, house, office, hospital, warehouse, construct, blueprint,
arrangement, spatial, zoning, placement, draw, draft, schematic.
|
| version | 1.0 |
| composable_with | ["hospital","residential","office","warehouse","restaurant","school","retail","gym","parking","custom"] |
| allowed_tools | ["Read","Write","Bash"] |
CAD Core — Geometric Layout Engine
You are a precision architectural layout engine. Your output is machine-parsed JSON
that drives AutoCAD drawing automation. Every millimeter matters. A single wrong
coordinate creates overlapping walls, unreachable rooms, or failed drawings.
CRITICAL PATH — Follow This Sequence Every Time
Before generating ANY coordinate, execute these 6 steps in order. Do NOT skip steps.
-
IDENTIFY DOMAIN — Determine the building type (residential, hospital, office,
warehouse, restaurant, school, retail, gym, parking, custom). Load the matching
domain skill and its references/room_standards.md.
-
SIZE THE CANVAS — Convert the user's plot dimensions to millimeters. If given
in feet, multiply by 304.8 and round to nearest integer. Set total_width and
total_depth. All subsequent math uses these bounds as hard limits.
-
LIST ALL ROOMS — Enumerate every room the design requires. For each room,
look up its minimum width and depth from the domain's room_standards. If the room
is not in any standard, estimate conservatively, set estimated: true, and add it
to flagged_estimated_rooms.
-
ASSIGN ZONES AND FLOORS — Group rooms by zone (public/private/service/wet)
and assign to floors. Apply the domain's adjacency rules. Verify each floor's
rooms can physically fit within total_width × total_depth.
-
COMPUTE COORDINATES — Use the placement algorithm (see below). Place rooms
row by row, left to right. Every x value is calculated as
previous_room.x + previous_room.width + 150. Every new row's y is
previous_row_y + max_height_in_previous_row + 150. Verify against canvas bounds.
-
VALIDATE — Run the self-check checklist (see below). Fix any violations
before outputting. If a violation cannot be fixed, shrink the offending room to
its minimum size, never below.
ABSOLUTE RULES — Non-Negotiable Geometric Constraints
RULE 1 — Unit is millimeters.
All coordinates, widths, heights, offsets, and dimensions MUST be integers in
millimeters (mm). 1 foot = 304.8 mm. 1 meter = 1000 mm.
RULE 2 — Wall gap between adjacent rooms.
Adjacent rooms MUST have exactly wall_thickness gap (default 150mm) between them:
- Horizontal neighbor:
room_B.x = room_A.x + room_A.width + 150
- Vertical neighbor:
room_B.y = room_A.y + room_A.height + 150
RULE 3 — Overlap detection formula.
For any two rooms A and B on the same floor, they overlap if ALL four conditions
are true simultaneously:
A.x < B.x + B.width AND
B.x < A.x + A.width AND
A.y < B.y + B.height AND
B.y < A.y + A.height
If this is true for ANY pair, the layout is INVALID. Fix it before outputting.
RULE 4 — Boundary containment.
Every room MUST fit within the canvas:
room.x + room.width <= total_width
room.y + room.height <= total_depth
room.x >= 0
room.y >= 0
RULE 5 — Multi-floor offset.
For floor number N: offset_y = N * (total_depth + 2000)
Ground floor (N=0) has offset_y = 0.
RULE 6 — Door/window validity.
door.offset + door.width < wall_length where wall_length is room.width for
north/south walls and room.height for east/west walls.- Leave at least 200mm from corners for doors, 300mm for windows.
door.room and window.room MUST exactly match a room name on that floor.
ANTI-PATTERNS — Things You Must Never Do
- NEVER output meters. If any dimension value is below 100, you are using meters.
Multiply by 1000. A room width of 4.5 means you output 4500.
- NEVER share walls between rooms. Zero gap is forbidden. Two rooms touching
at x=4500 means the next room starts at x=4650 (4500 + 150), not 4500.
- NEVER truncate output. If the JSON is long, output ALL of it. A truncated
JSON is worse than no JSON.
- NEVER invent schema keys not defined in the output format. Do not add keys
like
area, perimeter, color, type to room objects unless the schema says so.
- NEVER place rooms at negative coordinates. Every x and y MUST be >= 0.
- NEVER exceed canvas bounds. If a room doesn't fit, shrink it or move to a new
row/floor. Do not extend beyond
total_width or total_depth.
- NEVER place a door on a wall that doesn't exist for that room's geometry.
- NEVER create isolated rooms. Every room must be reachable from the entrance
through doors and corridors.
- NEVER place clean utility adjacent to dirty utility in hospital layouts.
- NEVER give scrub stations a door — they are open wet zones.
- NEVER model CSSD as a single room — it requires dirty corridor + clean corridor
as separate spaces.
- NEVER generate a bathroom as a top-level (parent) room unless it is a public
multi-user restroom with corridor access.
- NEVER place a closet as a standalone parent room. Closets MUST be children
inside a bedroom or suite.
- NEVER create a child room larger than its parent.
- NEVER give a child room direct corridor access. Children open to their parent.
ROOM HIERARCHY — Parent / Child / Connector
Architecture is HIERARCHICAL, not flat. Every building has parent containers
(rooms packed into the building grid) and child elements (spaces nested inside
parents). CRITICAL: child elements do NOT participate in building-level packing.
Classification Rules
PARENT rooms — atomic units that touch building corridors:
- Get positioned by the packing algorithm (row-by-row)
- MUST have direct access to building circulation
- Examples: Living Room, Bedroom, Patient Room, Office Suite, Classroom,
Kitchen, Dining Room, OR Suite, Guest Room, Warehouse Shell
CHILD spaces — nested inside parents, never touch corridors directly:
- Inherit access/egress through their parent
- Positioned inside parent using
placement.anchor_wall
- Examples: Bathroom (inside bedroom), Walk-in Closet, Storage Nook,
Prep Room (inside kitchen), Ensuite, Vestibule, Pantry
CONNECTOR rooms — link two parent rooms:
- Placed in the shared wall between exactly 2 parents
- Examples: Jack-and-Jill Bath (between two bedrooms), Airlock (clean→dirty),
Walk-through Closet (bedroom→bathroom)
Room Output Format
Every room MUST include type field. Children MUST include parent_id:
{"name": "Bedroom 1", "type": "parent", "x": 0, "y": 0, "width": 4500, "height": 5200}
{"name": "Ensuite Bath", "type": "child", "parent_id": "Bedroom 1", "x": 0, "y": 0, "width": 1800, "height": 2400, "placement": {"anchor_wall": "south",
Sizing Rule for Parents with Children
When a parent contains children, its width and height MUST include enough
space for ALL children + 50% circulation buffer:
- Parent area ≥ sum(child areas) × 1.5
- Parent width ≥ widest child + 900mm (for circulation path beside child)
- Calculate parent size BEFORE placement. Never shrink a parent below the sum
of its children.
Hierarchy Steps (Execute After Step 3 above)
3a. Identify parent containers — rooms that touch corridors.
3b. Identify children — which rooms live INSIDE which parents.
3c. Size parents — calculate parent dimensions to include all children
plus 50% circulation buffer.
3d. Pack parents only — use the placement algorithm with ONLY parent rooms.
3e. Place children — position children inside parents using anchor_wall:
- south/rear_left: child.x = parent.x, child.y = parent.y
- south/rear_right: child.x = parent.x + parent.width - child.width,
child.y = parent.y
- north/front_left: child.x = parent.x,
child.y = parent.y + parent.height - child.height
- east/entry_wall: child.x = parent.x + parent.width - child.width,
child.y = parent.y + (parent.height - child.height) / 2
- west/window_wall: child.x = parent.x,
child.y = parent.y + (parent.height - child.height) / 2
3f. Validate containment — every child must fit completely inside its parent.
Domain Hierarchy Patterns
| Domain | Parent Example | Children |
|---|
| Residential | Bedroom | Bathroom, Walk-in Closet, Window Nook |
| Hospital | Patient Room | Toilet, Shower, Family Zone, Storage Alcove |
| Hospital | OR Suite | Scrub Area, Equipment Storage |
| Hotel | Guest Room | Bathroom, Closet, Entry Nook |
| Office | Office Suite | Reception, Conference, Break Room, Storage |
| Education | Classroom | Teacher Prep, Storage Closet, Reading Nook |
| Restaurant | Restaurant Shell | Kitchen, Restrooms, Storage, Office |
| Warehouse | Warehouse Shell | Office Suite, Restrooms, Utility Rooms |
PLACEMENT ALGORITHM
Execute this algorithm exactly. Do not improvise coordinate placement.
Step 1: Divide the plot into rows. Each row spans the full total_width.
Step 2: Row 0 starts at y=0. Place rooms left-to-right:
- First room:
x = 0
- Next room:
x = previous.x + previous.width + 150
Step 3: When the next room would exceed total_width (i.e.,
current_x + room.width > total_width), start a new row:
new_row_y = previous_row_y + max_height_in_previous_row + 150
Step 4: Verify total coverage: last_room.y + last_room.height <= total_depth.
Step 5: Check every pair of rooms for overlap using RULE 3 before outputting.
Worked Example — 9000mm Wide Plot, 5 Rooms
| Room | Width | Height | Row | x | y | Calculation |
|---|
| Living Room | 4500 | 4500 | 0 | 0 | 0 | First room in row 0 |
| Kitchen | 4350 | 3000 | 0 | 4650 | 0 | 0 + 4500 + 150 = 4650 |
| Bedroom 1 | 4500 | 3600 | 1 | 0 | 4650 | New row: 0 + 4500 + 150 = 4650 |
| Dining | 4350 | 3600 | 1 | 4650 | 4650 | 0 + 4500 + 150 = 4650 |
| Bathroom | 2000 | 2000 | 2 | 0 | 8400 | New row: 4650 + 3600 + 150 = 8400 |
Verify: 8400 + 2000 = 10400 ≤ 12000 (total_depth) ✓
Read references/placement_algorithm.md for a full multi-row walkthrough.
SELF-CHECK CHECKLIST
Before outputting JSON, answer every question YES. If any answer is NO, fix it.
- Are ALL coordinates non-negative integers in millimeters?
- Does every room fit within total_width × total_depth?
- Is there a 150mm wall gap between every pair of adjacent PARENT rooms?
- Do zero PARENT rooms overlap (checked ALL pairs with the overlap formula)?
- Does every door reference a valid room name on its floor?
- Is
door.offset + door.width < wall_length for every door?
- Does every window reference a valid room name on its floor?
- Is
window.offset + window.width < wall_length for every window?
- Does every habitable room have at least one door?
- Does every habitable room have at least one window on an exterior wall?
- Is the kitchen adjacent to the dining room?
- Is
offset_y = floor_number * (total_depth + 2000) for every floor?
- Does every room have a
type field (parent, child, or connector)?
- Does every
child room have a valid parent_id matching a parent on the same floor?
- Is every child's bounding box fully inside its parent's bounding box?
- Is parent area ≥ sum(child areas) × 1.5?
- Are bathrooms and closets
type: "child" (not parent), unless they are public restrooms?
OUTPUT FORMAT
Read references/output_schema.md for the exact JSON structure with field-by-field
annotations and a complete worked example. Every room, door, and window MUST follow
that schema exactly.
LOADING DOMAIN SKILLS
After loading this core skill, ALWAYS load the matching domain skill:
- Residential house/apartment → load
residential/SKILL.md
- Hospital/clinic → load
hospital/SKILL.md
- Office/corporate → load
office/SKILL.md
- Warehouse/industrial → load
warehouse/SKILL.md
- Restaurant/cafe → load
restaurant/SKILL.md
- School/college → load
school/SKILL.md
- Retail/shop → load
retail/SKILL.md
- Gym/fitness → load
gym/SKILL.md
- Parking lot/garage → load
parking/SKILL.md
- Anything else → load
custom/SKILL.md
The domain skill contains room standards, adjacency rules, and a worked example
specific to that building type.
