Universal Options

Plan-first development: decompose, execute, verify cycle for AI agents

Require AI agents to write technical plans and receive approval before modifying code

Small changes, frequent testing, and iterative progress

Safe execution patterns: confirmation for destructive ops, reversible actions

Enter plan mode for non-trivial tasks and stop to re-plan when things go sideways

Write tests first, make them pass, refactor — the TDD cycle

Use subagents to keep the main context window clean and parallelize analysis

Update lessons files after corrections to prevent the same mistakes from recurring

Never mark a task complete without proving it works — run tests, check logs, demonstrate correctness

Pause to ask if there is a more elegant solution before implementing non-trivial changes

Fix bugs directly from logs and errors without waiting for step-by-step guidance

Plan first in a todo file, track progress, explain changes, and capture lessons after each task

Simplicity first, no laziness, and minimal impact — senior developer standards for every change

Core software architecture principles

Best practices for production-grade code

Public API design, naming conventions, and developer experience patterns for libraries

Configuration hierarchy, config files, environment variables, and persistent settings management

API versioning strategies, backward compatibility, and deprecation lifecycle management

REST/GraphQL API design, versioning, and error handling patterns

Idempotency patterns for safe retries, duplicate prevention, and reliable state mutations

Output formatting, color handling, progress indicators, and human vs machine-readable output patterns

Semver compliance, deprecation workflow, and breaking change management for libraries

Command-line application architecture, argument parsing, and UX patterns

Meaningful exit codes, error messages, and graceful failure patterns for CLI applications

Cursor-based pagination, filtering, sorting, and field selection for list endpoints

README structure, API reference, examples, and migration guides for library consumers

Interactive prompts, confirmation dialogs, and wizard-style flows for CLI applications

OpenAPI/Swagger specification, interactive docs, and API reference standards

Library design patterns, API surface, versioning, and distribution

Mobile application patterns

Web application architecture patterns

Dependency inversion and use-case driven design

Distributed service architecture patterns

Event sourcing, CQRS, and message-driven patterns

Separation of concerns and modular design

Guidelines for smart contract architecture.

Guidelines for embedded systems architecture.

Guidelines for desktop application architecture.

Guidelines for game development architecture.

Structured documentation files for AI agent context persistence across sessions

Best practices for keeping LLM context windows small, precise, and relevant

Agent rules files, AGENTS.md, and architecture documentation patterns

Inline comments for complex logic only

Exception-based error handling with try/catch blocks

Functional error handling using Result/Either/Optional types

UI error containment with Error Boundary patterns

A pragmatic mix of Try/Catch and Result Types suitable for modern applications.

Standardized commit messages for clear history and semantic versioning

Branch naming conventions and workflow patterns

Small, frequent commits directly to main or short-lived feature branches

Pull request conventions and review practices

Review practices for human and AI-generated code with security focus

General performance best practices

Using Linear via MCP for issue tracking, status updates, and project coordination

Jira and Azure DevOps for enterprise issue tracking and sprint management

Keeping pull requests small, focused, and rapidly reviewed

Breaking down epics into small, estimable, deliverable tasks

General security best practices

API-specific security patterns

Write and run isolated unit tests for every new function, method, or module

Test how components, services, and modules work together

Test real user flows through the full application stack

Enforce test coverage thresholds and run tests in CI pipelines

Package distribution, tree-shaking support, and multi-format builds for libraries

Container configuration, multi-stage builds, Compose for dev and e2e testing

Query style, migration patterns, naming conventions, and safety rules

Script conventions, error handling, portability, and safety

Workflow structure, caching, secrets management, and matrix builds

Module structure, state management, naming conventions, and plan/apply workflow