skills.rest
beelabstudio
beelabstudioOFFICIAL
Explore all skills by this author →
GitHub

software-engineer

Implements features, debugs code, and reviews pull requests following engineering best practices.

Updated Mar 14, 2026
Search Tags:#tdd#code review#debugging#refactoring#software development#clean architecture#pull requests
One-click install
npx skills add https://github.com/beelabstudio/ai --skill software-engineer-beelabstudio
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: software-engineer
Source: https://github.com/beelabstudio/ai/tree/main/skills/foundation/software-engineer
Command: npx skills add https://github.com/beelabstudio/ai --skill software-engineer-beelabstudio

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? This Skill provides structured software engineering guidance for implementing features, debugging issues, refactoring legacy code, and conducting code reviews, ensuring consistent quality standards across development work. ## Core Features & Use Cases - Feature Implementation: Design and write clean, testable, well-documented code using patterns like SOLID, DDD, and Clean Architecture. - Code Review & Quality: Conduct constructive code reviews and enforce clean code standards across pull requests. - Testing & Refactoring: Apply TDD/BDD practices with unit, integration, and end-to-end tests, and refactor legacy code when needed. - Use Case: When reviewing a pull request for a new REST API endpoint, use this Skill to evaluate architecture decisions, test coverage, and adherence to clean code principles before approving. ## Quick Start Review this pull request and check whether the code follows SOLID principles and has adequate test coverage.

Frequently Asked Questions about software-engineer

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

FAQPage Schema
How do I conduct an effective code review on a pull request?▼

Review pull requests by checking adherence to clean code standards, verifying test coverage, and evaluating architecture decisions against patterns like SOLID. Provide constructive feedback with clear descriptions of issues and suggested improvements.

How to refactor legacy code without breaking functionality?▼

Refactor legacy code incrementally by first adding unit and integration tests to lock in current behavior, then applying design patterns like Clean Architecture in small steps. Run the test suite after each change to catch regressions early.

What testing approach should I use for new features?▼

Use TDD or BDD to write tests before implementation, covering unit, integration, and end-to-end levels. This ensures the feature is testable by design and documents expected behavior through executable specifications.

Which design patterns apply to scalable system architecture?▼

SOLID principles, Domain-Driven Design, and Clean Architecture support scalable and maintainable systems. Choose based on domain complexity: DDD suits complex business logic, while Clean Architecture separates concerns across layers.

When should I not refactor working legacy code?▼

Avoid refactoring code that lacks test coverage and is stable, or when deadlines make regression risk unacceptable. Prioritize refactoring only when the code blocks new features or accumulates defects.

Related Skills

Explore More Software Engineering Skills→
novel-jpnovel-jp

learn-se-issue

Create a complete issue lifecycle exercise for tracking bugs from discovery to closure.

Official
Intermediate
FlorianBruniauxFlorianBruniaux
5.9k

deploy

Deploy an application to a configured environment.

Community
Basic
promptfoopromptfoo
24.7k

code-review

Reviews code for bugs, security vulnerabilities, and best practice violations.

Official
Basic
alexanderguyalexanderguy
4

philosophy

Guide architectural and collaboration decisions with engineering philosophy principles.

Community
Basic