home / skills / copyleftdev / sk1llz / skill-template

skill-template skill

safe

This skill writes Python code in the style and philosophy of a legendary engineer, applying their design principles to produce clean, robust solutions.

npx playbooks add skill copyleftdev/sk1llz --skill skill-template

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

Files (1)

SKILL.md

1.0 KB

---
name: engineer-name-style
description: Write code in the style and philosophy of [Engineer Name], applying their design principles, patterns, and mental models. Use when writing [language] code that requires [their specialty].
---

# [Engineer Name] Style Guide

## Overview

[Brief bio and why this engineer's approach matters]

## Core Philosophy

[2-3 sentences capturing their fundamental beliefs about software]

## Design Principles

1. **[Principle 1]**: [Explanation]
2. **[Principle 2]**: [Explanation]
3. **[Principle 3]**: [Explanation]

## When Writing Code

### Always
- [Guideline 1]
- [Guideline 2]

### Never
- [Anti-pattern 1]
- [Anti-pattern 2]

### Prefer
- [Pattern] over [Alternative] because [Reason]

## Code Patterns

See [patterns/](patterns/) for detailed examples.

## Additional Resources

- For detailed philosophy, see [philosophy.md](philosophy.md)
- For anti-patterns to avoid, see [anti-patterns/](anti-patterns/)
- For canonical examples, see [examples/](examples/)
- For references (books, talks), see [references.md](references.md)

Overview

This skill writes Python code in the style and philosophy of a named engineering mentor, applying their design principles, patterns, and mental models. It encodes their choices about clarity, modularity, and correctness so generated code matches their voice and standards. Use it when you need consistent, opinionated code that reflects a particular engineer's approach to problem solving.

How this skill works

The skill inspects the requested task, target language (Python), and the engineer's documented principles to produce code and explanations that follow their conventions. It enforces naming, structure, error handling, and testing patterns consistent with the engineer's mental models. When requested, it also generates short rationale notes that explain why each choice maps back to the engineer's core philosophy.

When to use it

Implementing new modules that must match an established codebase style
Refactoring code to align with a specific engineer's design patterns
Generating library code where long-term maintainability is critical
Creating examples or teaching materials that demonstrate a named engineer's approach
Producing code reviews or fixes that should adhere to an expert's standards

Best practices

State the target engineer, language, and specialty in the prompt so outputs stay focused
Prefer small, well-named functions and explicit interfaces over complex one-offs
Favor composition and simple abstractions; avoid premature generalization
Include comprehensive but concise docstrings and unit tests for core behaviors
Provide brief rationale comments linking choices to the engineer's principles

Example use cases

Generate a Python data-processing module following the engineer's immutability and type-strict patterns
Refactor a legacy function into testable components that match the engineer's dependency-injection style
Produce a canonical example for a library feature demonstrating the engineer's recommended error-handling idioms
Create an onboarding code sample that teaches the engineer's preferred architecture and naming conventions

FAQ

Can the skill adapt if the engineer's guide conflicts with project constraints?

Yes — specify constraints and the skill will prioritize them, then apply the engineer's principles where compatible and document any deliberate deviations.

Will generated code include tests and documentation?

By default the skill adds concise docstrings and at least one unit test for core behavior; request extended test suites or more detailed docs when needed.