Agent skill

Nav Simplify

by qf-studio in qf-studio/navigator

Simplify and refine code for clarity, consistency, and maintainability while preserving all functionality.

MITAuto-check: notesDevelopment

Install Nav Simplify

skills CLI
$ npx skills add qf-studio/navigator --skill nav-simplify -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install qf-studio/navigator nav-simplify --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/qf-studio/navigator.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/nav-simplify .claude/skills/nav-simplify && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
nav-simplify
GitHub stars
355
Token cost
~3.8k tokens
SKILL.md length
963 words
Files
6 (incl. scripts)
Skills in repo
32
Repo updated
First seen
Licence
MIT

At a glance

Simplify and refine code for clarity, consistency, and maintainability while preserving all functionality.

  • Works in 7 steps: Identify Modified Code → Load Simplification Configuration → Read Project Standards → …
  • Development work in your project
  • SKILL.md covers Core Principle, When to Invoke, Execution Steps and Configuration Options, plus 5 more sections
  • Runs Python scripts from its folder; calls git and python3

What it does

Nav Simplify is an agent skill from qf-studio/navigator. Simplify and refine code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code. Auto-invoke after implementation skills or on-demand.

Its SKILL.md is about 3.8k tokens, which your agent loads only when the skill is triggered. The skill folder holds 6 other files, including scripts (for example `scripts/change_reporter.py`, `scripts/code_analyzer.py` and `scripts/cost_analyzer.py`).

It sits in Development. The repository describes itself as: Finish What You Start — Context engineering for Claude Code. Sessions last 20+ exchanges instead of crashing at 7. The licence is MIT.

When your agent uses it

  • Development work in your project

Example prompts

  • “/nav-simplify”

Requirements

  • Python 3
  • Pre-approved tools (allowed-tools): Read, Write, Edit, Bash, Glob, Grep

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Identify Modified Code
  2. Load Simplification Configuration
  3. Read Project Standards
  4. Analyze Each File
  5. 5: ROI Gate (when scoring.mode = "roi")
  6. Apply Simplification Rules
  7. Generate Simplified Code

What it can do on your machine

Read from SKILL.md and the folder at commit 3bb9eac. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves these tools, so the agent can use them without asking each time:

    • Read
    • Write
    • Edit
    • Bash
    • Glob
    • Grep

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 5 files in scripts/ (Python), which the agent can run.

    Shell commands in SKILL.md call:

    • git
    • python3

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md. Its commands use git, which can reach the network depending on how they are called.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Nav Simplify loads about 3.8k tokens when it runs. Until then it costs about 52 tokens; SKILL.md has 963 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~52
When it runs · the whole SKILL.md, loaded when a task matches
~3.8k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NotePre-approves every shell command (allowed-tools: Bash)SKILL.md
    allowed-tools: Read, Write, Edit, Bash, Glob, Grep

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from qf-studio/navigator at commit 3bb9eac, republished under its MIT licence (© qf-studio). 963 words, ~3,790 tokens.

Download SKILL.mdSave it as .claude/skills/nav-simplify/SKILL.md (or your agent's skills folder). This skill also uses 5 other files; get the full folder from GitHub.
name
nav-simplify
description
Simplify and refine code for clarity, consistency, and maintainability while preserving all functionality. Focuses on recently modified code. Auto-invoke after implementation skills or on-demand.
allowed-tools
Read, Write, Edit, Bash, Glob, Grep
version
1.0.0
model
opus

Navigator Code Simplification Skill

Simplify recently modified code for clarity, consistency, and maintainability while preserving exact functionality. Based on Anthropic's internal code-simplifier pattern.

Core Principle

Clarity over brevity. Functionality preserved absolutely.

You are an expert code simplification specialist. Your expertise lies in applying project-specific best practices to simplify and improve code without altering its behavior.

When to Invoke

Auto-invoke after:

  • backend-endpoint skill completes
  • frontend-component skill completes
  • database-migration skill completes
  • Any implementation task with code changes

Manual invoke when user says:

  • "simplify this code"
  • "review for clarity"
  • "clean up recent changes"
  • "refactor for readability"
  • "simplify modified files"

DO NOT invoke if:

  • No code was modified (docs-only changes)
  • User explicitly says "skip simplification"
  • Files are configuration only (JSON, YAML)

Execution Steps

Step 1: Identify Modified Code

Option A: Git-based detection (preferred)

bash
# Get files modified in current session/commits
git diff --name-only HEAD~3 -- '*.ts' '*.tsx' '*.js' '*.jsx' '*.py' '*.go' '*.rs' 2>/dev/null || \
git diff --name-only --cached -- '*.ts' '*.tsx' '*.js' '*.jsx' '*.py' '*.go' '*.rs' 2>/dev/null || \
git diff --name-only -- '*.ts' '*.tsx' '*.js' '*.jsx' '*.py' '*.go' '*.rs'

Option B: User-specified scope

If user mentions specific files or directories, use those instead.

Option C: Recent conversation context

Analyze conversation for files that were written/edited in this session.

Step 2: Load Simplification Configuration

Check for project-specific configuration:

bash
if [ -f ".agent/.nav-config.json" ]; then
  python3 -c "import json; c=json.load(open('.agent/.nav-config.json')); s=c.get('simplification',{}); print('auto_apply=' + str(s.get('auto_apply', False)).lower()); print('enabled=' + str(s.get('enabled', True)).lower())"
fi

Default configuration:

json
{
  "simplification": {
    "enabled": true,
    "trigger": "post-implementation",
    "scope": "modified",
    "model": "opus",
    "skip_patterns": ["*.test.*", "*.spec.*", "*.md", "*.json", "*.yaml"],
    "max_file_size": 50000,
    "auto_apply": false,
    "preserve_comments": true
  }
}
Autonomous context check (CRITICAL)

After loading config, determine the invocation mode:

Autonomous (no human in the loop):

  • Invoked from nav-loop VERIFY or COMPLETE phase
  • Invoked from nav-workflow COMPLETE phase
  • NAV_AUTONOMOUS=1 env var set
  • Triggered by autonomous-completion protocol

Interactive (human reviewing):

  • Direct user request ("simplify this code")
  • Mid-implementation manual invocation

Decision matrix:

auto_applyContextAction
trueautonomousApply directly (Step 7 silent)
trueinteractiveApply directly, show summary
falseautonomousSKIP simplification entirely — emit warning, return to caller. Never pause an autonomous flow waiting for approval.
falseinteractiveShow diff per file, prompt for approval

When skipping in autonomous-mode-with-false, emit:

⚠️  nav-simplify skipped: auto_apply=false but invoked autonomously.
   To enable: set simplification.auto_apply=true in .agent/.nav-config.json
   To disable cleanly: set simplification.enabled=false
Step 3: Read Project Standards

Load from CLAUDE.md (required):

Read(file_path: "CLAUDE.md")

Extract coding standards:

  • Preferred patterns (function vs arrow, explicit returns)
  • Naming conventions
  • Import ordering
  • Error handling patterns
  • Framework-specific guidelines
Step 4: Analyze Each File

For each modified file, analyze for simplification opportunities:

Complexity Indicators (look for):

  • Deep nesting (> 3 levels)
  • Long functions (> 50 lines)
  • Redundant code patterns
  • Unclear variable names
  • Nested ternary operators
  • Over-abstraction
  • Dead code
  • Inconsistent patterns

Run analysis:

bash
PLUGIN_DIR="${CLAUDE_PLUGIN_ROOT:-$(cat "${NAVIGATOR_CONFIG_HOME:-${XDG_CONFIG_HOME:-$HOME/.config}/navigator}/plugin-root" 2>/dev/null)}"
[ -d "$PLUGIN_DIR/skills" ] || PLUGIN_DIR="$HOME/.claude/plugins/marketplaces/navigator-marketplace"
# Pass --scoring roi to enable cost/benefit gating (default: complexity,
# legacy behavior).
python3 "$PLUGIN_DIR/skills/nav-simplify/scripts/code_analyzer.py" --file "$file" --scoring roi
Step 4.5: ROI Gate (when scoring.mode = "roi")

If simplification.scoring.mode is "roi" in .agent/.nav-config.json (or --scoring roi was passed), the analyzer emits benefit_score, cost_score, roi_score, and a gate_action field. Honor the gate:

gate_actionBehavior
skipSkip this file. Emit a one-line reason with ROI math. Continue to next file.
suggestForce interactive mode for this file regardless of auto_apply. Show diff + reason.
applyProceed with Step 5+ as normal (honor auto_apply).

Skip emission format:

⏭️  {file} — low ROI (B={B}/10, C={C}/10, ROI={R}). Skipping.
   {reason}

{reason} summarizes the dominant cost factor (e.g., "stable file (412 days), 8 import references" or "below skip_below threshold").

Mode is opt-in. When scoring.mode == "complexity" (default), Step 4.5 is a no-op and behavior is unchanged from prior versions.

Step 5: Apply Simplification Rules

Anthropic Simplification Rules:

  1. Preserve Functionality: Never change what the code does - only how it does it. All original features, outputs, and behaviors must remain intact.

  2. Apply Project Standards: Follow CLAUDE.md coding standards:

    • Use ES modules with proper import sorting
    • Prefer function keyword over arrow functions (if project standard)
    • Use explicit return type annotations
    • Follow proper React/Vue component patterns
    • Use proper error handling patterns
    • Maintain consistent naming conventions
  3. Enhance Clarity:

    • Reduce unnecessary complexity and nesting
    • Eliminate redundant code and abstractions
    • Improve readability through clear names
    • Consolidate related logic
    • Remove unnecessary comments that describe obvious code
    • AVOID nested ternary operators - use switch/if-else
    • Choose clarity over brevity - explicit > compact
  4. Maintain Balance - Avoid over-simplification that could:

    • Reduce code clarity or maintainability
    • Create overly clever solutions
    • Combine too many concerns
    • Remove helpful abstractions
    • Prioritize "fewer lines" over readability
    • Make code harder to debug or extend
Show full SKILL.md (367 more words)Show less
Step 6: Generate Simplified Code

For each file with improvements:

  1. Read current file content
  2. Apply simplification rules
  3. Verify functionality unchanged (logic review)
  4. Generate diff or replacement

Output format:

📝 Simplifying: {filename}

Changes:
- [Line X] Flattened nested ternary to switch statement
- [Line Y] Extracted repeated logic to helper function
- [Line Z] Renamed `x` to `userCount` for clarity

Diff:
```diff
- const result = a ? (b ? c : d) : e;
+ let result;
+ if (a && b) {
+   result = c;
+ } else if (a) {
+   result = d;
+ } else {
+   result = e;
+ }

### Step 7: Apply Changes

Branch on the decision matrix from Step 2:

**Autonomous + `auto_apply: false`**: skip entirely, emit the warning, return.

**Autonomous + `auto_apply: true`**: apply each change directly with `Edit()`. Do not prompt.

**Interactive + `auto_apply: true`**: apply directly, show summary at end.

**Interactive + `auto_apply: false`**: show diff per file, prompt `Apply this change? [y/N]`, apply only on yes.

When applying:

Edit( file_path: "{file}", old_string: "{original}", new_string: "{simplified}" )


### Step 8: Generate Summary

╔══════════════════════════════════════════════════════╗ ║ ║ ║ 🧹 Code Simplification Complete ║ ║ ║ ╚══════════════════════════════════════════════════════╝

📊 Summary: ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Files analyzed: {N} Files simplified: {M} Changes applied: {X} ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

📝 Changes by category: • Clarity improvements: {count} • Nesting reduction: {count} • Naming improvements: {count} • Pattern consolidation: {count}

✅ Functionality: Preserved (no behavior changes) ✅ Standards: Applied from CLAUDE.md

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━


## Predefined Functions

### scripts/code_analyzer.py

**Purpose**: Analyze code file for simplification opportunities

**Arguments**:
- `--file`: Path to file to analyze
- `--standards`: Path to CLAUDE.md (optional)
- `--output`: Output format (json, text)

**Returns**:
```json
{
  "file": "src/utils/auth.ts",
  "issues": [
    {
      "line": 45,
      "type": "nested_ternary",
      "severity": "medium",
      "suggestion": "Convert to switch or if-else"
    },
    {
      "line": 78,
      "type": "deep_nesting",
      "severity": "high",
      "depth": 5,
      "suggestion": "Extract to helper function"
    }
  ],
  "complexity_score": 7.2,
  "recommended_actions": 3
}

When invoked with --scoring roi (or simplification.scoring.mode == "roi"), the output additionally contains:

json
{
  "benefit_score": 6.1,
  "cost_score": 4.3,
  "roi_score": 1.4,
  "gate_action": "suggest",
  "scoring_explanation": {
    "benefit": {"issue_density": 0.4, "severity_impact": 5.2, "in_active_diff": true},
    "cost": {"estimated_touch_lines": 32, "file_loc": 287, "days_since_modified": 12, "import_references": 3},
    "thresholds": {"skip_below": 0.5, "suggest_below": 1.5, "auto_apply_at": 1.5},
    "cost_floor": 0.5
  }
}
scripts/simplification_rules.py

Purpose: Apply project-specific simplification rules

Arguments:

  • --file: Path to file
  • --claude-md: Path to CLAUDE.md for project standards
  • --dry-run: Preview changes without applying

Returns: Simplified code with change annotations

scripts/change_reporter.py

Purpose: Generate human-readable change summary

Arguments:

  • --changes: JSON array of changes made
  • --format: Output format (markdown, text, json)

Returns: Formatted change report

Configuration Options

Add to .agent/.nav-config.json:

json
{
  "simplification": {
    "enabled": true,
    "trigger": "post-implementation",
    "scope": "modified",
    "model": "opus",
    "skip_patterns": ["*.test.*", "*.spec.*"],
    "max_file_size": 50000,
    "auto_apply": false,
    "preserve_comments": true,
    "rules": {
      "avoid_nested_ternary": true,
      "max_nesting_depth": 3,
      "max_function_length": 50,
      "prefer_explicit_returns": true,
      "consolidate_imports": true
    },
    "scoring": {
      "mode": "complexity",
      "skip_below": 0.5,
      "suggest_below": 1.5,
      "auto_apply_at": 1.5,
      "cost_floor": 0.5
    }
  }
}

Options:

  • enabled: Enable/disable simplification
  • trigger: "manual" | "post-implementation" | "pre-commit"
  • scope: "modified" | "staged" | "all"
  • model: Preferred model for simplification (opus recommended)
  • skip_patterns: Glob patterns to skip
  • max_file_size: Skip files larger than this (bytes)
  • auto_apply: Apply changes without confirmation
  • preserve_comments: Keep meaningful comments
  • rules: Specific simplification rules
  • scoring.mode: "complexity" (legacy, default) or "roi" (opt-in cost/benefit gating)
  • scoring.skip_below: ROI threshold below which files are skipped entirely
  • scoring.auto_apply_at: ROI threshold at and above which auto-apply is honored
  • scoring.cost_floor: Minimum cost denominator to prevent ROI explosions

Integration Points

Autonomous Completion

When integrated with autonomous completion protocol:

Implement → Verify → **Simplify** → Commit → Archive

Simplification runs automatically after verification passes, before commit.

Loop Mode

Added to VERIFY phase completion indicators:

Completion Indicators:
  [x] Tests passing
  [x] Code simplified  ← Added
  [ ] Documentation updated

Examples

Example 1: Nested Ternary Simplification

Before:

typescript
const status = isLoading ? 'loading' : hasError ? 'error' : isSuccess ? 'success' : 'idle';

After:

typescript
function getStatus(isLoading: boolean, hasError: boolean, isSuccess: boolean): string {
  if (isLoading) return 'loading';
  if (hasError) return 'error';
  if (isSuccess) return 'success';
  return 'idle';
}

const status = getStatus(isLoading, hasError, isSuccess);
Example 2: Deep Nesting Reduction

Before:

typescript
function processUser(user: User) {
  if (user) {
    if (user.isActive) {
      if (user.hasPermission) {
        if (user.email) {
          sendEmail(user.email);
        }
      }
    }
  }
}

After:

typescript
function processUser(user: User) {
  if (!user?.isActive) return;
  if (!user.hasPermission) return;
  if (!user.email) return;

  sendEmail(user.email);
}
Example 3: Unclear Naming

Before:

typescript
const x = users.filter(u => u.a && !u.d).map(u => u.n);

After:

typescript
const activeUserNames = users
  .filter(user => user.isActive && !user.isDeleted)
  .map(user => user.name);

Error Handling

File too large:

⚠️  Skipping {filename} ({size} bytes)
    Exceeds max_file_size limit ({limit} bytes)

    Override with: "simplify {filename} --force"

No changes needed:

✅ {filename} - Already follows best practices
   No simplification opportunities found.

Functionality risk detected:

⚠️  Potential behavior change detected in {filename}

    Line {N}: Changing conditional logic

    Review required before applying:
    [Show diff]

    Apply this change? [y/N]:

Success Criteria

Simplification is successful when:

  • All modified files analyzed
  • Functionality preserved (verified)
  • Project standards applied (from CLAUDE.md)
  • No nested ternaries remain
  • Nesting depth ≤ 3 levels
  • Clear variable/function names
  • Change summary generated

Notes

  • Model preference: Opus recommended for quality judgment
  • Scope default: Only recently modified files (avoid churn)
  • Skip tests: Test files usually follow different patterns
  • Preserve intent: Comments explaining "why" should be kept
  • No over-optimization: Clarity > minimal lines

This skill integrates Anthropic's internal code-simplifier pattern into Navigator's workflow, ensuring code quality before commit.

© qf-studio, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 5 other files (scripts) in skills/nav-simplify of qf-studio/navigator.

  • SKILL.md
  • scripts/change_reporter.py
  • scripts/code_analyzer.py
  • scripts/cost_analyzer.py
  • scripts/simplification_rules.py
  • scripts/test_roi_scoring.py

Open the folder on GitHubat commit 3bb9eac

Compare with similar skills

Nav Simplify next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Nav Simplify compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Nav Simplify this skillqf-studio/navigator355—~3.8kAutomated safety check: NotesMIT
Trellis Session Insightmindfold-ai/Trellis15k4 repos~1.7kAutomated safety check: PassAGPL-3.0
Warp Factory Fileswarpdotdev/warp65k1 repos~2.5kAutomated safety check: PassAGPL-3.0
Migrate Core Code to Submodulestinyhumansai/openhuman42k—~2.6kAutomated safety check: PassGPL-3.0
Analyze Logsactivepieces/activepieces25k1 repos~1.6kAutomated safety check: PassMIT
GitHub Review Iterationprisma/orm48k—~2.2kAutomated safety check: PassApache-2.0

Similar skills

  • Trellis Session Insight

    mindfold-ai/Trellis

    Reach into past AI conversation history through the trellis mem CLI.

    15k GitHub starsUsed in 4 repos~1.7k tokens
    DevelopmentAuto-check passed
  • Warp Factory Files

    warpdotdev/warp

    Authors and edits file-based Warp software factory definitions rooted at factory.yaml, covering agents, automations, scorers and webhooks, and validates them before a pull request.

    65k GitHub starsUsed in 1 repo~2.5k tokens
    DevelopmentAuto-check passed
  • Migrate Core Code to Submodules

    tinyhumansai/openhuman

    Plans and carries out moving non-host-specific code and its tests from the OpenHuman core into vendored tiny submodule libraries, then releases the submodule and re-pins the host.

    42k GitHub stars~2.6k tokensUpdated today
    DevelopmentAuto-check passed
  • Analyze Logs

    activepieces/activepieces

    Analyze application logs from the .evlog/logs/ directory. An agent skill from activepieces/activepieces.

    25k GitHub starsUsed in 1 repo~1.6k tokens
    DevelopmentAuto-check passed
  • Official

    Runs a loop on a GitHub pull request: fetch review state, triage comments into actions, implement them and resolve threads, repeating until nothing actionable is left.

    48k GitHub stars~2.2k tokensUpdated today
    DevelopmentAuto-check passed
  • Release

    PrefectHQ/fastmcp

    Cut a FastMCP release end to end. An agent skill from PrefectHQ/fastmcp.

    28k GitHub stars~2.9k tokensUpdated today
    DevelopmentAuto-check passed

More from qf-studio/navigator

All 32 skills in this repo
  • Nav Start

    qf-studio/navigator

    Load Navigator documentation navigator when starting development session, resuming work, or beginning new feature.

    355 GitHub stars~4.7k tokensUpdated yesterday
    Auto-check: notes
  • Backend Endpoint

    qf-studio/navigator

    Create REST/GraphQL API endpoint with validation, error handling, and tests.

    355 GitHub stars~4.5k tokensUpdated yesterday
    Auto-check: notes
  • Backend Test

    qf-studio/navigator

    Generate backend tests (unit, integration, mocks) for existing code.

    355 GitHub stars~1.5k tokensUpdated yesterday
    Auto-check: notes
  • Database Migration

    qf-studio/navigator

    Create database migration with schema changes and rollback. An agent skill from qf-studio/navigator.

    355 GitHub stars~3.7k tokensUpdated yesterday
    Auto-check: notes
  • Frontend Component

    qf-studio/navigator

    Create React/Vue component with TypeScript, tests, and styles.

    355 GitHub stars~4.5k tokensUpdated yesterday
    Auto-check: notes
  • Frontend Test

    qf-studio/navigator

    Generate frontend component tests (React Testing Library, Vue Test Utils, snapshot) for existing components.

    355 GitHub stars~1.6k tokensUpdated yesterday
    Auto-check: notes

Questions about Nav Simplify

What does Nav Simplify do?

Simplify and refine code for clarity, consistency, and maintainability while preserving all functionality. Nav Simplify is an agent skill from qf-studio/navigator. Simplify and refine code for clarity, consistency, and maintainability while preserving all functionality.

When should I use Nav Simplify?

Nav Simplify fits situations like: development work in your project.

How do I install Nav Simplify in Claude Code?

Run `npx skills add qf-studio/navigator --skill nav-simplify -a claude-code`. Or copy the skill folder (skills/nav-simplify in qf-studio/navigator) into .claude/skills/nav-simplify in your project. Claude Code loads it when a task matches its description.

How do I install Nav Simplify in Codex?

Run `npx skills add qf-studio/navigator --skill nav-simplify -a codex`. Or copy the skill folder (skills/nav-simplify in qf-studio/navigator) into .agents/skills/nav-simplify in your project. Codex loads it when a task matches its description.

Can I use Nav Simplify in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add qf-studio/navigator --skill nav-simplify -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/nav-simplify, .gemini/skills/nav-simplify, .github/skills/nav-simplify and .opencode/skills/nav-simplify in your project.

What does Nav Simplify need to run?

Going by SKILL.md and its folder, Nav Simplify needs Python for the scripts in its folder and the command-line tools its instructions call (git and python3). Our summary lists: Python 3. Its frontmatter pre-approves these tools: Read, Write, Edit, Bash, Glob, Grep.

Does Nav Simplify access the network?

SKILL.md contains no URLs. Its commands use git, which can reach the network depending on how they are called. This is read from the text; nothing was executed.

Is Nav Simplify safe to install?

Our automated static check of SKILL.md found notes only (pre-approves every shell command (allowed-tools: bash)), nothing it rates as a warning. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Nav Simplify use?

Nav Simplify is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Nav Simplify use?

About 3.8k tokens (SKILL.md is roughly 15k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Nav Simplify?

Skills that share tags, products or a category with Nav Simplify: Trellis Session Insight (mindfold-ai/Trellis, 15k stars), Warp Factory Files (warpdotdev/warp, 65k stars), Migrate Core Code to Submodules (tinyhumansai/openhuman, 42k stars) and Analyze Logs (activepieces/activepieces, 25k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Nav Simplify?

qf-studio (a GitHub organization) maintains it in qf-studio/navigator, which has 355 GitHub stars. The repository holds 32 skills in this directory. The repository was last updated on October 8, 2026.

Source: qf-studio/navigator on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.