playbooks

home / skills / benchflow-ai / skillsbench / morph-apply

morph-apply skill

/registry/terminal_bench_2.0/full_batch_reviewed/terminal_bench_2_0_large-scale-text-editing/environment/skills/morph-apply

This skill edits large files quickly using Morph Apply, performing targeted changes without full reads, saving tokens and time.

npx playbooks add skill benchflow-ai/skillsbench --skill morph-apply

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.9 KB
---
name: morph-apply
description: Fast file editing via Morph Apply API (10,500 tokens/sec, 98% accuracy)
allowed-tools: [Bash, Read]
---

# Morph Fast Apply

Fast, AI-powered file editing using the Morph Apply API. Edit files without reading them first. Processes at 10,500 tokens/sec with 98% accuracy.

## When to Use

- Fast file edits without reading entire file first
- Batch edits to a file (multiple changes in one operation)
- When you know what to change but file is large
- Large files where reading would consume too many tokens

## Key Pattern: Code Markers

Use `// ... existing code ...` (or language-appropriate comments) to mark where edits go:

```python
# ... existing code ...
try:
    result = process()
except Exception as e:
    log.error(e)
# ... existing code ...
```

The API intelligently places your edit in the right location.

## Usage

### Add error handling
```bash
uv run python -m runtime.harness scripts/mcp/morph_apply.py \
    --file "src/auth.py" \
    --instruction "Add error handling to login function" \
    --code_edit "# ... existing code ...
try:
    user = authenticate(credentials)
except AuthError as e:
    log.error(f'Auth failed: {e}')
    raise
# ... existing code ..."
```

### Add logging
```bash
uv run python -m runtime.harness scripts/mcp/morph_apply.py \
    --file "src/api.py" \
    --instruction "Add debug logging" \
    --code_edit "# ... existing code ...
logger.debug(f'Processing request: {request.id}')
# ... existing code ..."
```

### TypeScript example
```bash
uv run python -m runtime.harness scripts/mcp/morph_apply.py \
    --file "src/types.ts" \
    --instruction "Add user validation" \
    --code_edit "// ... existing code ...
if (!user) throw new Error('User not found');
if (!user.isActive) throw new Error('User inactive');
// ... existing code ..."
```

## Parameters

| Parameter | Description |
|-----------|-------------|
| `--file` | File path to edit (required) |
| `--instruction` | Human description of the change (required) |
| `--code_edit` | Code snippet with markers showing where to place edit (required) |

## vs Claude's Edit Tool

| Tool | Best For |
|------|----------|
| **morph-apply** | Fast edits, don't need to read file first, large files, batch edits |
| **Claude Edit** | Small precise edits when file is already in context |

**Use morph-apply when:**
- File is not in context and reading it would be expensive
- File is very large (>500 lines)
- Making multiple related edits at once
- You know the context of the change (function name, class, etc.)

**Use Claude Edit when:**
- File is already in context from prior Read
- Very precise edits requiring exact old/new string matching
- Small files (<200 lines)

## MCP Server Required

Requires `morph` server in mcp_config.json with `MORPH_API_KEY`.

## Performance

- **Speed**: 10,500 tokens/sec
- **Accuracy**: 98% correct placement
- **Token savings**: Don't need to read entire file first

Overview

This skill enables fast, AI-powered file edits using the Morph Apply API, letting you modify code without reading the full file first. It places edits precisely using marker-based snippets and operates at very high throughput (10,500 tokens/sec) with about 98% placement accuracy. Use it to save tokens and time when changing large files or applying batch edits.

How this skill works

Provide a target file path, a human instruction describing the change, and a code snippet that includes language-appropriate comment markers (e.g., // ... existing code ... or # ... existing code ...). The API finds the correct location and injects your snippet without loading the entire file into context. It supports multiple related edits in one operation and is optimized for large files where reading the full contents would be costly.

When to use it

  • You need to edit very large files (>500 lines) without reading them first
  • You want to apply multiple related changes in one operation (batch edits)
  • You know where the change belongs (function, class, or logical region) but not the full file context
  • You want to save tokens and time when modifying many files or heavy codebases

Best practices

  • Mark insertion points with clear language-appropriate comment markers (e.g., // ... existing code ... or # ... existing code ...)
  • Keep code_edit snippets minimal and focused on the actual change to reduce ambiguity
  • Include a concise, action-oriented instruction describing intent (why the change matters)
  • Test changes in a staging branch because placement is highly accurate but not infallible
  • Use for structural edits and logging/type additions; prefer string-exact edit tools for tiny precise replacements

Example use cases

  • Add error handling to a login function in a large auth module without reading the whole file
  • Insert debug or audit logging across several large service files in one run
  • Add validation checks or type guards in TypeScript files when the files are too large to load
  • Batch-upgrade function signatures or insert wrapper code across multiple modules
  • Quickly inject telemetry or tracing setup into existing code regions

FAQ

Do I need to provide the full file contents?

No. You only provide the file path, an instruction, and a code snippet with markers. The API edits the file without you reading it first.

How precise is placement and how fast is it?

Placement accuracy is about 98% and throughput is around 10,500 tokens per second, making it suitable for large-scale edits.