What is the role of planning in the develop skill?

Planning is mandatory for non-trivial changes; include at least 3 clarifying questions and wait for explicit approval.

How should I manage repository changes safely?

Follow Git Safety: ask before initializing repos or switching branches, and make atomic commits.

How do I ensure changes fit the project style and quality?

Document intent (WHY), match existing style, consider edge cases, and verify changes after editing; consult language references like Python when needed.

develop

Scanned

npx machina-cli add skill aiskillstore/marketplace/develop --openclaw

Files (1)

SKILL.md

1.4 KB

Develop Skill

Core Principles

Clean Code: Follow readable, maintainable patterns.
Fail Early: Never catch unexpected exceptions silently; let them bubble up.
Simplicity: Prefer the simplest working solution.

Planning

For non-trivial changes:

Present a plan with at least 3 clarifying questions (and proposed answers).
Wait for explicit approval before implementation.
For complex strategy, use the plan skill.

Implementation & Git

Git Safety

Permission First: Always ask before initializing repos or switching branches.
Atomic Commits: Group related changes logically.

Code Quality

Focus on WHY: Document intent, not mechanics.
Edge Cases: Consider and test error scenarios.
Existing Style: Match existing patterns and formatting.

Language-Specific References

When working with specific languages, consult the following references:

Python: Refer to references/python.md.

File Operations

Prefer edit_file: Use for targeted changes; avoid rewriting full files.
Verification: Always verify changes after editing.
Tools: Use fd and rg for exploration; standard shell tools for navigation.

Source

git clone https://github.com/aiskillstore/marketplace/blob/main/skills/0xmsc/develop/SKILL.mdView on GitHub

Overview

Develop is a skill set for exploring, developing, editing, and refactoring code. It centers on clean code, fail-fast thinking, and simplicity, guiding work with planning, explicit approvals, and safe Git practices to improve code quality and maintainability.

How This Skill Works

Begin with core principles (Clean Code, Fail Early, Simplicity). For non-trivial changes, present a plan with at least 3 clarifying questions and wait for explicit approval before implementation. When editing, prefer targeted changes with edit_file, commit atomically, and verify outcomes; consult language-specific references (e.g., Python) to stay aligned with existing patterns.

When to Use It

Planning and exploring a legacy or complex codebase to identify refactor opportunities.
Implementing non-trivial features or architectural changes.
Performing code quality improvements and pattern convergence.
Making targeted edits with minimal surface area using edit_file.
Auditing error handling and edge cases and adding tests.

Quick Start

Step 1: Identify scope and write a plan with at least 3 clarifying questions.
Step 2: Seek explicit approval before implementing changes.
Step 3: Implement with targeted edits (edit_file), commit atomically, and verify results.

Best Practices

Plan with at least 3 clarifying questions and proposed answers before any major change.
Wait for explicit approval before implementing complex plans.
Keep changes atomic by grouping related edits and avoiding rewrites.
Document intent (WHY) rather than mechanics; explain the reason for changes.
Match existing style and formatting; test edge cases and verify results after editing.

Example Use Cases

Plan a refactor in a Python codebase by posing clarifying questions and awaiting approval before touching code.
Fix a bug by targeted edit_file edits in a single module, followed by an atomic commit.
Audit a function for edge cases and add tests and small adjustments rather than sweeping rewrites.
Refactor a module to improve readability while preserving behavior and compatibility.
When in doubt, consult references/python.md to align with existing patterns.

Frequently Asked Questions

Add this skill to your agents