Private launch

Turn agent code to shippable commits.

Commitly turns agent-written code into clean, reviewable commits by fixing lint issues, updating docs, adding tests, and preparing the final commit.

No spam. We only email when it's time.

commitly.tools/demo

How it works

From diff to done.

Four steps between your code and a commit worth shipping.

01

Lint

Fixes issues before they leak into the commit.

02

Docs

Updates docs when code changes require it.

03

Tests

Adds missing test coverage before you ship.

04

Commit

Writes a clean, consistent commit message from the final diff.

Currently supports Go, TypeScript, and Python projects.

Your rules and conventions

Your standards, built into every fix.

Define how each stage should run in your codebase, then let every agent follow the same playbook.

Set stage-specific guidance for how issues should be fixed

Lint fixes land differently than doc updates. Each stage gets its own skill.

Encode conventions once instead of repeating prompts

Your commit format, test framework, doc style — defined once, applied every time.

Keep fixes consistent across repos, and agents

Same skills, same output. Regardless of who runs it or where.

# Resolving golangci-lint Violations

You are fixing lint issues reported by golangci-lint
against the project's .golangci.yml configuration.

## Common Rules

**errcheck** — Unchecked error return
```go
// Banned
json.Unmarshal(data, &v)

// Allowed
if err := json.Unmarshal(data, &v); err != nil {
    return fmt.Errorf("unmarshal: %w", err)
}
```

**unused** — Declared but unused variable
Remove the declaration, or replace with `_` if
the call has required side effects.

**govet** — Suspicious constructs
```go
// Banned: copying a lock value
var mu sync.Mutex
mu2 := mu

// Allowed: use a pointer
mu2 := &sync.Mutex{}
```

## Constraints

- Never suppress with //nolint without a reason
- Fix the root cause, not the symptom
- Preserve existing error wrapping patterns
- Run golangci-lint again after each fix

Lint — 3 items

Remove unused import useState

src/components/dashboard.tsx:4

Resolved

Replace any with explicit type

src/lib/api.ts:22

Add return type to fetchUser()

src/lib/api.ts:47

Pending

Item-level control

Every fix is a decision, not a surprise.

One item, one diff, one decision. Nothing ships without you.

Set the permission level

Strict, safe, or YOLO. You decide how much the agent can do on its own.

Accept or skip, then move on

You decide what ships, one item at a time.

Full diff before anything lands

The agent proposes. You see the change. Then you call it.

Works with any agentic setup

Agents come and go. The pipeline stays.

Every stage, every task, every handoff — orchestrated through MCP.

Same pipeline, everywhere

VSCode, Claude Code, any MCP client. Commitly runs the same way regardless.

Agent-agnostic by design

Codex today, Claude Code tomorrow. The commit workflow doesn't change.

State belongs to the pipeline

Switch agents mid-session. Pick up exactly where you left off.

FAQ

Questions? Answered.