Power User Setup Checklist

This checklist transforms a basic Droid installation into a fully optimized development environment. Each section builds on the previous one—complete them in order for best results.

Each section can be done independently if you prefer to spread it out.

Using Factory App? Most of this guide applies to both the Droid CLI and the Factory App. Where the experience differs, we’ve noted the Factory App-specific approach.

Level 1: Essential Setup

These foundational items give you the biggest immediate impact.

Install the Factory IDE Plugin

The IDE plugin provides real-time context—open files, errors, selections—so Droid sees what you see.VSCode/Cursor:

Open Extensions (Cmd+Shift+X)
Search “Factory”
Install and reload

Verify: Run droid and check for “IDE connected” in the status bar.

Create your AGENTS.md

Create a basic AGENTS.md at your repository root:

# Project Guidelines

## Build & Test
- Build: `npm run build`
- Test: `npm test`
- Lint: `npm run lint`

## Code Style
- Use TypeScript strict mode
- Prefer functional components in React
- Write tests for new features

Start minimal—you’ll expand this as you work. See the AGENTS.md guide for more examples.

Configure your default model

Set your preferred model in settings:CLI:

droid
> /settings
# Navigate to Model and select your default

Factory App: Use the model selector dropdown in the chat interface.Recommendation: Start with Claude Opus 4.5 (default) for complex work, switch to Haiku 4.5 or GPT-5.1-Codex for routine tasks.

Checkpoint: You should now have IDE integration, basic project context, and your preferred model configured.

Level 2: Memory & Context

Build persistent memory so Droid remembers your preferences across sessions.

Create a memories file

Create ~/.factory/memories.md for personal preferences:

# My Development Preferences

## Code Style
- I prefer arrow functions over function declarations
- I like early returns over nested conditionals
- I use 2-space indentation

## Testing
- I use React Testing Library, not Enzyme
- I prefer integration tests over unit tests for components
- Mock external APIs, not internal modules

## Past Decisions
- [2024-01] Chose Zustand over Redux for state management
- [2024-02] Using Tailwind CSS for styling

Update this file whenever you find yourself repeating instructions to Droid.

Reference memories in AGENTS.md

Add to your AGENTS.md:

## Personal Preferences
Refer to `~/.factory/memories.md` for my coding preferences and past decisions.

Create project-specific memories (optional)

For team projects, create .factory/memories.md:

# Project Memories

## Architecture Decisions
- We use the repository pattern for data access
- All API routes go through the /api/v1 prefix
- Feature flags are managed via LaunchDarkly

## Known Issues
- The auth service has a 5-second timeout issue (#123)
- Legacy users table uses snake_case columns

Checkpoint: Droid now has access to your preferences and project history without you repeating them.

Want automated memory capture? Set up a hook to automatically save memories when you say “remember this:”. See Memory Management for setup instructions.

Level 3: Rules & Conventions

Organize your coding standards so Droid follows them consistently.

Create a rules directory

Create .factory/rules/ in your project:

.factory/
└── rules/
    ├── typescript.md
    ├── testing.md
    └── security.md

Add TypeScript rules

Create .factory/rules/typescript.md:

# TypeScript Conventions

## General
- Use `interface` for object types, `type` for unions/intersections
- Avoid `any` - use `unknown` with type guards instead
- Export types alongside their implementations

## React Components
- Use functional components with TypeScript FC type
- Props interfaces should be named `{ComponentName}Props`
- Use `React.ReactNode` for children, not `React.ReactChild`

## Imports
- Group imports: React, external libs, internal modules, types
- Use absolute imports from `@/` prefix
- Avoid barrel files (index.ts re-exports) for performance

Add testing rules

Create .factory/rules/testing.md:

# Testing Conventions

## File Organization
- Test files live next to source: `Component.tsx` → `Component.test.tsx`
- Integration tests go in `__tests__/integration/`
- E2E tests go in `e2e/`

## Test Structure
- Use descriptive test names: "should [action] when [condition]"
- One assertion per test when possible
- Use `beforeEach` for common setup, not `beforeAll`

## Mocking
- Mock at the boundary (API calls, not internal functions)
- Use MSW for API mocking in integration tests
- Reset mocks in `afterEach`

Reference rules in AGENTS.md

Update your AGENTS.md:

## Coding Standards
Follow the conventions documented in:
- `.factory/rules/typescript.md` - TypeScript and React patterns
- `.factory/rules/testing.md` - Testing conventions
- `.factory/rules/security.md` - Security requirements

Checkpoint: Your coding standards are now documented and Droid will follow them consistently.

Enforce rules automatically: Use PostToolUse hooks to run linters after edits. See Code Validation hooks for examples.

Level 4: Skills & Automation

Add reusable skills and automation hooks.

Three ways to automate:

Skills — Droid invokes them based on task context
Hooks — Run automatically on specific events
Custom Slash Commands — You invoke with /command-name

Create a prompt refiner skill

Create ~/.factory/skills/prompt-refiner/SKILL.md:

---
name: prompt-refiner
description: Improve prompts before sending them to get better results. Use when you want to refine a task description.
---

# Prompt Refiner

## Instructions

When the user wants to refine a prompt:

1. Ask for their draft prompt or task description
2. Analyze it for:
   - Clarity: Is the goal specific and measurable?
   - Context: Does it include relevant background?
   - Constraints: Are requirements and limitations stated?
   - Examples: Would examples help clarify expectations?
3. Suggest an improved version with explanations
4. Offer to iterate if needed

## Good Prompt Patterns

- Start with the outcome: "Create a..." not "I want you to..."
- Include acceptance criteria: "The result should..."
- Specify format: "Return as JSON/markdown/code"
- Mention constraints: "Must be compatible with...", "Should not modify..."

Add an auto-formatting hook

Run /hooks and add a PostToolUse hook for automatic formatting:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Create|Edit|ApplyPatch",
        "hooks": [
          {
            "type": "command",
            "command": "cd \"$FACTORY_PROJECT_DIR\" && npx prettier --write \"$(jq -r '.tool_input.file_path' 2>/dev/null || echo '')\" 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

This automatically formats files after Droid edits them.

Add a test-on-edit hook (optional)

Run related tests after edits:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|ApplyPatch",
        "hooks": [
          {
            "type": "command",
            "command": "cd \"$FACTORY_PROJECT_DIR\" && jq -r '.tool_input.file_path' | xargs -I {} npm test -- --findRelatedTests {} --passWithNoTests 2>/dev/null || true"
          }
        ]
      }
    ]
  }
}

Checkpoint: You now have reusable skills and automatic formatting/testing.

Level 5: Token Optimization

Fine-tune for cost efficiency without sacrificing quality.

Enable Spec Mode for complex work

Use Shift+Tab or /spec before starting features that touch multiple files. This prevents expensive false starts.

Configure model switching

Set up a spec mode model for planning:

droid
> /settings
# Set Spec Mode Model to a reasoning-heavy model

Use Opus 4.5 for planning, then Sonnet or Codex for implementation.

Run the readiness report

Check your project’s AI-readiness:CLI:

droid
> /readiness-report

Factory App: View your readiness score in the Agent Readiness Dashboard.Address high-impact items first—linting, type checking, and fast tests dramatically reduce token waste.

Quick Reference: File Locations

Purpose	Personal	Project
Skills	`~/.factory/skills/<name>/SKILL.md`	`.factory/skills/<name>/SKILL.md`
Memory	`~/.factory/memories.md`	`.factory/memories.md`
Rules	`~/.factory/rules/*.md`	`.factory/rules/*.md`
Settings	`~/.factory/settings.json`	`.factory/settings.json`
Hooks	`~/.factory/hooks.json`	`.factory/hooks.json`
Agent instructions	`~/.factory/AGENTS.md`	`./AGENTS.md`
Custom droids	`~/.factory/droids/<name>.md`	`.factory/droids/<name>.md`

Verification Checklist

Run through this checklist to verify your setup:

IDE plugin shows “connected” when running Droid
AGENTS.md exists with build/test commands
Memories file created with your preferences
Rules directory with at least one rules file
At least one custom skill created
Auto-formatting hook configured
Readiness report shows Level 2 or higher

Next Steps

Prompt Crafting

Learn model-specific prompting techniques

Token Efficiency

Strategies for reducing token usage

Memory Management

Advanced memory and context patterns

Rules Guide

Organizing team conventions effectively

Power User

Building

Skills

Hooks

Droid Exec (Headless)

Level 1: Essential Setup

Level 2: Memory & Context

Level 3: Rules & Conventions

Level 4: Skills & Automation

Level 5: Token Optimization

Quick Reference: File Locations

Verification Checklist

Next Steps

Prompt Crafting

Token Efficiency

Memory Management

Rules Guide

​Level 1: Essential Setup

​Level 2: Memory & Context

​Level 3: Rules & Conventions

​Level 4: Skills & Automation

​Level 5: Token Optimization

​Quick Reference: File Locations

​Verification Checklist

​Next Steps

Prompt Crafting

Token Efficiency

Memory Management

Rules Guide

Level 1: Essential Setup

Level 2: Memory & Context

Level 3: Rules & Conventions

Level 4: Skills & Automation

Level 5: Token Optimization

Quick Reference: File Locations

Verification Checklist

Next Steps