editing

Apply planned edits step-by-step with edit_file and run_tests.

28|2|Updated Feb 21, 2026
One-click install
npx skills add https://github.com/MyPrototypeWhat/context-chef --skill editing-myprototypewhat
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: editing
Source: https://github.com/MyPrototypeWhat/context-chef/tree/main/packages/core/src/modules/skill/__fixtures__/valid2
Command: npx skills add https://github.com/MyPrototypeWhat/context-chef --skill editing-myprototypewhat

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

The editing skill helps you apply an existing plan to a codebase or document in a controlled way, reducing mistakes and keeping changes aligned with the intended sequence.

Core Features & Use Cases

  • Step-by-step application: Converts a plan into incremental edits so each change is reviewable and traceable.
  • Continuous verification: Runs tests after each change to catch regressions early.
  • Supported actions: Uses edit_file, run_tests, and read_file to modify safely while inspecting context as needed.

Example use case: You have a refactor plan to update multiple functions and adjust failing tests; use this skill to implement each step in order and confirm correctness after every edit.

Quick Start

Use the editing skill to apply the current plan one step at a time to your project and run tests after each change.

Frequently Asked Questions about editing

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I apply a code refactor plan with step-by-step changes and test verification?

Step-by-step code refactoring involves applying incremental edits to your project using edit_file, followed by running tests after each modification. This controlled approach ensures every change is traceable and catches regressions early by verifying correctness before moving to the next step.

What is the best way to execute a staged bug-fix rollout while keeping changes aligned with the intended sequence?

The best way to execute a staged bug-fix rollout is by applying a pre-existing plan incrementally. You modify files one step at a time and run tests after each change, ensuring the rollout remains controlled, mistakes are reduced, and changes stay aligned with the intended sequence.

Can I use incremental edits for staged documentation or configuration updates where ordering matters?

Yes, you can use incremental edits for staged documentation or configuration updates where ordering matters. The process applies a plan one step at a time, inspecting needed context with read_file and modifying safely with edit_file to maintain strict control over the update sequence.

Does test verification after each change help catch regressions during incremental refactors?

Test verification after each change directly helps catch regressions during incremental refactors by running tests immediately following every edit. This continuous verification loop confirms correctness and isolates failures to the specific step that caused them.

Do I need a previously created plan before starting tool-assisted edits in my project?

Yes, you need a previously created plan before starting tool-assisted edits. The skill applies an existing plan to your codebase or document in a controlled way, converting the plan into incremental, reviewable edits rather than generating the plan itself.