How to use Hornero

Getting started

When you first open Hornero it loads a small welcome example: a few birds. Poke at it. Everything you can do is in that picture.

• Click a node to select it and edit it in the right-hand inspector.
• Drag a node to move it.
• Drag the dot on a node's right edge onto another node to link them.
• Add nodes from the toolbar (Block, Capability, Bucket) or with the keyboard.

To start from scratch, use New (in the desktop app, File > New). To get the example back at any time, open the ? panel and click Load welcome example, or use Help > Load Welcome Example.

The model: four ideas

How they connect

• Inheritance (block → parent block): a child sees all of its ancestor's props and methods. A prop with the same name shadows the inherited one.
• Implements (block ↔ capability): the block promises every method of the capability.
• Uses (a typed reference): a prop whose type points at another block or capability, like nest: struct(Nest), draws a "uses" edge.
• Bucket dependencies: derived automatically. If anything in bucket A points at something in bucket B, you get A → B. If they point at each other, the edge goes red.

Working on the canvas

Linking nodes

Every node has a dot on its right edge. Drag it onto another node; Hornero reads the link from the two endpoints:

• block → block = the first extends the second.
• block ↔ capability = the block implements the capability.
• anything → bucket = move that node into the bucket.

Editing a node

Select a block or capability and the inspector on the right shows its name, bucket, props/methods, and what it inherits or implements. With nothing selected, the inspector edits project-level title, description and notes.

Buckets and focus

Click the eye on a bucket to collapse it. Collapse buckets (toolbar button) to focus on the cross-bucket dependency arrows, which is where circular dependencies show up.

Flows

Switch the toolbar toggle from Arch to Flow to see flows as numbered badges over your blocks. A flow is a tree of steps; each step is pinned to a block and may call capabilities that block implements.

• Step labels (1, 2a, 2b, 3...) are derived from the tree. Number is depth; letters are siblings.
• A step can only call a capability its block actually implements (inheritance counts). Calls that stop resolving are kept and flagged, never dropped silently.
• One flow per scenario. Only one is shown at a time; pick the active flow from the toolbar.

The Markdown file

Every diagram is a plain .md file: readable, hand-editable, and diffable in a pull request. Export .md writes it (with canvas positions); Import .md reads it back. The format is small:

# Birds

## Bucket: Birds
description: Birds and the nest they build.

## Capability: CanSing
bucket: Birds
methods:
- sing(): Song

## Block: Bird
bucket: Birds
extends: Animal
implements: CanSing
props:
- wingspan: number

Headings declare nodes (## Bucket: / ## Block: / ## Capability:). Under each, key: value lines set fields, and props: / methods: lists hold the contents. Flows go at the end as ## Flow: sections. Names are matched exactly, so when you rename a node, update every reference to it.

Chat with Claude

Open the chat panel (toolbar → Chat, or ⌘R) to ask Claude about the design or have it edit the diagram for you. It runs on your local claude CLI and your existing Claude Code subscription, so there is no API key and nothing is uploaded to a server.

Claude reads and edits the open diagram file directly, and you watch each step. Pick the model and effort at the top of the panel, and use Improve layout to have it reposition every node for readability.

Keyboard shortcuts