Existing Projects

The problem: Your project has been running for months. The model has no idea about the patterns you've established, the ADRs you've made, or the invariants your system depends on. Every session it guesses.

edikt audits what you have and installs guardrails that match.

Flow

1. Open your existing project in Claude Code
2. Run /edikt:init
3. edikt detects the project has history and runs a codebase audit
4. Review and confirm the recommendations

What the audit finds

edikt detected:
  Language:     Go 1.22 (go.mod)
  Framework:    Chi v5 (go.mod)
  Lint config:  .golangci-lint.yaml found
  Git history:  847 commits over 14 months

Recommended rules:
  ✓ code-quality    (base — always recommended)
  ✓ testing         (base — always recommended)
  ✓ security        (base — always recommended)
  ✓ error-handling  (base — always recommended)
  ✓ go              (detected: Go 1.22)
  ✓ chi             (detected: Chi v5)
  ○ architecture    (opt-in — add if you want layer boundary enforcement)

Toggle rules on/off, then confirm.

The difference it makes

Here's the model before edikt on an established Go project:

// Asked to add a new repository method
func (r *OrderRepo) FindByStatus(status string) []Order {
    var orders []Order
    r.db.Where("status = ?", status).Find(&orders)  // no error handling
    return orders                                     // silently returns nil on error
}

After edikt installs error-handling.md and go.md:

func (r *OrderRepo) FindByStatus(ctx context.Context, status string) ([]Order, error) {
    var orders []Order
    if err := r.db.WithContext(ctx).Where("status = ?", status).Find(&orders).Error; err != nil {
        return nil, fmt.Errorf("find orders by status %q: %w", status, err)
    }
    return orders, nil
}

Context propagation. Error wrapping. Return value. The model got there because it read the rules, not because you corrected it again.

Capturing what already exists

Your project has implicit decisions baked into the code. Surface them:

/edikt:adr:new we use repository pattern for all data access
/edikt:adr:new all monetary amounts use decimal not float64
/edikt:invariant:new payments table is append-only, never update or delete rows

These become ADRs and invariants in docs/. The model reads them in every future session. The decisions stop living only in your head.

If you have scattered docs — READMEs, old ADR folders, wiki pages — bring them in:

/edikt:docs:intake

edikt scans and organizes them into the standard structure.

Tips

• Commit the generated files first — it's the same tree either way, see what edikt writes
• The first session after init, run /edikt:context and then capture a few invariants you know about
• If the audit misses something, edit .edikt/config.yaml and re-run init
• Run /edikt:doctor to verify the setup is healthy