Features

Features are a Quack-exclusive concept for documenting and tracking the logical building blocks of your project. Rather than leaving your architecture implicit in the code, Features give each meaningful part of your system a name, a description, and a home.

What Features Are

A Feature represents a distinct unit of your project — a module, a capability, a domain concept. It is not tied 1:1 to a file or a folder. A Feature might span several files, or describe a cross-cutting concern like "Authentication" or "Token Tracking."

Features serve three purposes:

1. Documentation: They record what each part of your system does, which files implement it, and how data flows through it.
2. Context for agents: When an agent reads a Feature doc, it gains precise, human-curated knowledge about that area of the codebase — faster and more reliably than searching code from scratch.
3. Project tracking: Features can be tracked on the Kanban Board and visualized on the Whiteboard.

Creating a Feature

Using the /create feature command

Type in chat:

/create feature

The agent will prompt you for a name and description, then generate a Feature document using the feature-creator skill.

Using the feature-creator skill directly

Use the feature-creator skill to document the authentication module

The skill scaffolds the markdown file, fills in the Files table by inspecting the relevant code, and writes the Data Flow section.

Feature Document Format

Each Feature is a markdown file with YAML frontmatter:

markdown
---
id: "024"
name: Authentication
tags: [security, auth, session]
status: active
created: 2025-03-10
---

# Authentication

Short description of what this feature does and why it exists.

## Files

| File | Role |
|------|------|
| `src/auth/validateToken.ts` | Token validation logic |
| `src/auth/session.ts` | Session lifecycle management |
| `src-tauri/src/auth.rs` | Rust backend auth commands |

## Data Flow

User login form -> validateToken() [src/auth/validateToken.ts] -> Tauri invoke: verify_session [src-tauri/src/auth.rs] -> Session stored in Zustand [src/stores/sessionStore.ts]

## Notes

Any quirks, known issues, or decisions worth preserving.

Auto-Numbering

Features are numbered automatically in sequence: 001, 002, 003, and so on. The numbering is project-local and never reused, so a feature ID always refers to the same concept even if features are renamed or reorganized.

Integration with the Whiteboard

Every Feature with a linked file appears as a node on the Whiteboard canvas. The node's label is the Feature name, and its layer (UI Components, Business Logic, Infrastructure) is inferred from its files and tags.

You can:

• Click a node on the Whiteboard to open its Feature doc
• Drag a Feature node into the chat to use it as context
• Group related Feature nodes into a nested component

Integration with the Kanban Board

Features can be attached to Kanban tasks. When you create a task, select a Feature to associate it. This links the task to the part of the codebase it affects, making it easier to track what has been worked on and what is still pending.

Integration with Chat

Mention a Feature in any message using @ autocomplete:

@Authentication — the token refresh logic has a bug when the session expires silently

The agent receives the full Feature document as additional context, so it understands exactly which files and flows are relevant before it starts working.

Sidebar Features Panel

The Features panel in the side panel lists all Features for the active project. From there you can:

• Search by name or tag
• Open any Feature doc in the Code Editor
• See which Features are linked to active Kanban tasks
• Create a new Feature

Best Practices

Keep Features focused. A Feature should describe one coherent concern. If a doc is covering three unrelated things, split it into three Features.

Update when code changes. When your agent modifies files covered by a Feature, update the Files table and Data Flow section. Stale docs are worse than no docs.

Use descriptive tags. Tags like [api, crud, postgres] or [ui, forms, validation] make it fast to find the right Feature when working across a large project.

Let the agent help. After implementing a new module, ask your agent to create or update the Feature doc. The feature-creator skill is designed for this and will produce a consistent, accurate result.

Previous: Code Editor

Next: Automations