> ## Documentation Index
> Fetch the complete documentation index at: https://docs.factory.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Power User Setup Checklist

> Complete checklist to configure Droid for maximum effectiveness with IDE integration, memory, skills, and automation.

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.

<Note>
  Each section can be done independently if you prefer to spread it out.
</Note>

<Info>
  **Using Factory App?** Most of this guide applies to both CLI and [Factory App](/web/getting-started/overview). Where the experience differs, we've noted the App-specific approach.
</Info>

***

## Level 1: Essential Setup

These foundational items give you the biggest immediate impact.

<Steps>
  <Step title="Install the Factory IDE Plugin">
    The IDE plugin provides real-time context—open files, errors, selections—so Droid sees what you see.

    **VSCode/Cursor:**

    1. Open Extensions (`Cmd+Shift+X`)
    2. Search "Factory"
    3. Install and reload

    **Verify:** Run `droid` and check for "IDE connected" in the status bar.
  </Step>

  <Step title="Create your AGENTS.md">
    Create a basic [`AGENTS.md`](/cli/configuration/agents-md) at your repository root:

    ```markdown theme={null}
    # 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](/cli/configuration/agents-md) for more examples.
  </Step>

  <Step title="Configure your default model">
    Set your preferred model in settings:

    **CLI:**

    ```bash theme={null}
    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.
  </Step>
</Steps>

<Check>
  **Checkpoint:** You should now have IDE integration, basic project context, and your preferred model configured.
</Check>

***

## Level 2: Memory & Context

Build persistent memory so Droid remembers your preferences across sessions.

<Steps>
  <Step title="Create a memories file">
    Create `~/.factory/memories.md` for personal preferences:

    ```markdown theme={null}
    # 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.
  </Step>

  <Step title="Reference memories in AGENTS.md">
    Add to your `AGENTS.md`:

    ```markdown theme={null}
    ## Personal Preferences
    Refer to `~/.factory/memories.md` for my coding preferences and past decisions.
    ```
  </Step>

  <Step title="Create project-specific memories (optional)">
    For team projects, create `.factory/memories.md`:

    ```markdown theme={null}
    # 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
    ```
  </Step>
</Steps>

<Check>
  **Checkpoint:** Droid now has access to your preferences and project history without you repeating them.
</Check>

<Tip>
  **Want automated memory capture?** Set up a hook to automatically save memories when you say "remember this:". See [Memory Management](/guides/power-user/memory-management#automatic-memory-capture) for setup instructions.
</Tip>

***

## Level 3: Rules & Conventions

Organize your coding standards so Droid follows them consistently.

<Steps>
  <Step title="Create a rules directory">
    Create `.factory/rules/` in your project:

    ```
    .factory/
    └── rules/
        ├── typescript.md
        ├── testing.md
        └── security.md
    ```
  </Step>

  <Step title="Add TypeScript rules">
    Create `.factory/rules/typescript.md`:

    ```markdown theme={null}
    # 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
    ```
  </Step>

  <Step title="Add testing rules">
    Create `.factory/rules/testing.md`:

    ```markdown theme={null}
    # 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`
    ```
  </Step>

  <Step title="Reference rules in AGENTS.md">
    Update your `AGENTS.md`:

    ```markdown theme={null}
    ## 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
    ```
  </Step>
</Steps>

<Check>
  **Checkpoint:** Your coding standards are now documented and Droid will follow them consistently.
</Check>

<Tip>
  **Enforce rules automatically:** Use [PostToolUse hooks](/cli/configuration/hooks-guide) to run linters after edits. See [Code Validation hooks](/reference/hooks-reference) for examples.
</Tip>

***

## Level 4: Skills & Automation

Add reusable skills and automation hooks.

<Info>
  **Three ways to automate:**

  * **[Skills](/cli/configuration/skills)** — Droid invokes them based on task context
  * **[Hooks](/cli/configuration/hooks-guide)** — Run automatically on specific events
  * **[Custom Slash Commands](/cli/configuration/custom-slash-commands)** — You invoke with `/command-name`
</Info>

<Steps>
  <Step title="Create a prompt refiner skill">
    Create `~/.factory/skills/prompt-refiner/SKILL.md`:

    ```markdown theme={null}
    ---
    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..."
    ```
  </Step>

  <Step title="Add an auto-formatting hook">
    Run `/hooks` and add a PostToolUse hook for automatic formatting:

    ```json theme={null}
    {
      "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.
  </Step>

  <Step title="Add a test-on-edit hook (optional)">
    Run related tests after edits:

    ```json theme={null}
    {
      "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"
              }
            ]
          }
        ]
      }
    }
    ```
  </Step>
</Steps>

<Check>
  **Checkpoint:** You now have reusable skills and automatic formatting/testing.
</Check>

***

## Level 5: Token Optimization

Fine-tune for cost efficiency without sacrificing quality.

<Steps>
  <Step title="Enable Spec Mode for complex work">
    Use `Shift+Tab` or `/spec` before starting features that touch multiple files. This prevents expensive false starts.
  </Step>

  <Step title="Configure model switching">
    Set up a spec mode model for planning:

    ```bash theme={null}
    droid
    > /settings
    # Set Spec Mode Model to a reasoning-heavy model
    ```

    Use Opus 4.5 for planning, then Sonnet or Codex for implementation.
  </Step>

  <Step title="Run the readiness report">
    Check your project's AI-readiness:

    **CLI:**

    ```bash theme={null}
    droid
    > /readiness-report
    ```

    **Factory App:** View your readiness score in the [Agent Readiness Dashboard](/web/agent-readiness/dashboard).

    Address high-impact items first—linting, type checking, and fast tests dramatically reduce token waste.
  </Step>
</Steps>

***

## 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**              | In settings.json                    | In settings.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

<CardGroup cols={2}>
  <Card title="Prompt Crafting" href="/guides/power-user/prompt-crafting" icon="wand-magic-sparkles">
    Learn model-specific prompting techniques
  </Card>

  <Card title="Token Efficiency" href="/guides/power-user/token-efficiency" icon="gauge-high">
    Strategies for reducing token usage
  </Card>

  <Card title="Memory Management" href="/guides/power-user/memory-management" icon="brain">
    Advanced memory and context patterns
  </Card>

  <Card title="Rules Guide" href="/guides/power-user/rules-conventions" icon="scale-balanced">
    Organizing team conventions effectively
  </Card>
</CardGroup>