safe-editing

Modify code with small, focused changes and post-change validation.

Updated Mar 26, 2026
One-click install
npx skills add https://github.com/bernardohaha/Daylyou --skill safe-editing
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: safe-editing
Source: https://github.com/bernardohaha/Daylyou/tree/main/.claude/skills/safe-editing
Command: npx skills add https://github.com/bernardohaha/Daylyou --skill safe-editing

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill guarantees that all code modifications within the Daylyou project are small, safe, and easily testable, preventing regressions and simplifying the review process. It enforces best practices for incremental and reliable code changes, saving you from debugging headaches and ensuring code stability.

Core Features & Use Cases

  • Incremental Changes: Promotes small, focused alterations, avoiding large, complex refactors by breaking them into manageable, reviewable steps.
  • Type Safety Enforcement: Mandates adherence to /types definitions, preventing the introduction of untyped or inconsistent data structures and maintaining code integrity.
  • Testability Guidance: Recommends specific commands (e.g., npm run dev, npm run lint) and manual steps for validating changes, ensuring functionality and preventing bugs.
  • Use Case: When updating a core component, this Skill ensures you only modify relevant sections, update associated types, and provide clear testing instructions, minimizing the risk of introducing bugs and streamlining the development process.

Quick Start

I need to update the HabitCard component. Use the safe-editing skill to guide me on how to make the changes, ensuring they are small, safe, and testable.

Frequently Asked Questions about safe-editing

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

FAQPage Schema
How do I make safe code changes without introducing bugs?

Safe code changes minimize risk by keeping modifications small and focused, showing clear before/after context, validating types against `/types` definitions, and running validation commands like `npm run dev` and `npm run lint` to catch collateral effects before review.

What's the best way to refactor code while maintaining type safety?

Type-safe refactoring requires respecting `/types` by validating existing types before use and updating type definitions and all usages when adding fields, ensuring consistency across the codebase and preventing runtime mismatches.

How do I structure code changes for easier review?

Structure changes incrementally by breaking larger refactors into manageable, reviewable steps, displaying only modified code blocks with context, and documenting testing steps so reviewers can quickly validate functionality and scope.

When should I apply incremental code changes instead of large refactors?

Apply incremental changes when modifying existing code, fixing bugs, adding features, or touching shared types or interfaces; this approach prevents regressions, simplifies reviews, and reduces debugging complexity compared to monolithic refactors.

What testing should I include after making code changes?

Post-change testing includes running development and linting commands—such as `npm run dev` and `npm run lint`—plus manual validation steps specific to your changes, ensuring no collateral effects and confirming intended functionality.