mcpField
S
senior-software-engineer

senior-software-engineer

github.com/rade-nugrohoDevelopment1237 installsUpdated 23w ago
Repository

About senior-software-engineer

A general software engineering skill for senior engineers, supporting service design, technical proposals, code review, safe refactoring, and team guidance. It focuses on trade-offs, maintainability, reliability, and operability rather than stack-specific delivery or enterprise-wide architecture.

Key features

  1. 01Design services, modules, and APIs
  2. 02Write RFCs and technical specifications
  3. 03Review code correctness and maintainability
  4. 04Refactor safely while preserving behavior
  5. 05Plan work breakdown and delivery risks

Use cases

  1. 01Compare service designs and trade-offs
  2. 02Review pull requests and test coverage
  3. 03Add characterization tests before legacy refactoring
  4. 04Break down engineering work and identify risks

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/rade-nugroho/agentic-enteprises-skill --skill senior-software-engineer

After installing, type/senior-software-engineerin Claude Code to confirm it loaded.

Bundled files

References and scripts installed along with SKILL.md.

references/
code_review.md
refactoring_quality.md
reliability_patterns.md
rfc_technical_leadership.md
system_design.md

Details

From the project README

Senior Software Engineer

When to Use

  • Design services, modules, APIs, or technical approaches across general software stacks
  • Write RFCs, technical specs, decomposition plans, or engineering trade-off analysis
  • Review PRs for correctness, maintainability, reliability, operability, and test coverage
  • Refactor legacy code safely while preserving behavior
  • Mentor engineers on implementation quality, estimates, and delivery risks

When NOT to Use

  • Build stack-specific full-stack product features end to end → senior-fullstack-developer, fullstack-software-engineer
  • Focus only on React/UI architecture and accessibility → senior-frontend-software-engineer
  • Choose rollout plans, canaries, or cutover strategy → deployment-strategist
  • Provision infrastructure, Kubernetes, or IaC → infrastructure-engineer
  • Make enterprise-wide architecture decisions or ADR review gates → senior-system-architecture

Related skills

NeedSkill
React/Next + vertical feature deliveryfullstack-software-engineer, senior-fullstack-developer
Senior front-end architecture and a11ysenior-frontend-software-engineer
Rollout plans and release strategydeployment-strategist
CI/CD implementationdevops
Cloud/K8s/Terraforminfrastructure-engineer
Requirements and BRDsbusiness-analyst
AI/LLM product featuresai-engineer
Cross-service ADRs, NFRs, architecture reviewsenior-system-architecture
Profiling, load tests, latency SLOsperformance-engineer

Core Workflows

1. Technical design (RFC)
  1. State problem, constraints, and non-goals
  2. List options with trade-offs (at least two alternatives)
  3. Recommend one; define interfaces and data contracts
  4. Identify risks: scale, failure modes, migration, operability
  5. Define success metrics and rollout approach (link deployment-strategist if needed)

Deliverable: short RFC or design doc with diagram (C4 or sequence for critical paths).

See references/system_design.md for templates, boundaries, and consistency patterns.

2. Implementation planning

Break work into:

SliceOutcome
FoundationTypes, interfaces, skeleton with tests
Core behaviorHappy path end-to-end
Edge casesErrors, idempotency, authz
OperabilityLogs, metrics, runbooks
CleanupRemove flags, deprecate old path

Estimate each slice; call out unknowns and spikes.

See references/rfc_technical_leadership.md for estimation and decomposition.

3. Code review (senior bar)

Review order: correctness → design → operability → style.

CheckQuestion
CorrectnessEdge cases, races, error handling
API designClear contracts, backward compatibility
SecurityAuthz, injection, secrets
TestsMeaningful cases, not snapshot noise
OperabilityLogs, metrics, configurable limits
MaintainabilityCoupling, naming, duplication

Leave actionable comments; distinguish blocker vs nit.

See references/code_review.md for rubric and comment patterns.

4. Refactoring and quality

When to refactor: before adding feature in tangled module, or when change touches same area third time.

Approach:

  1. Add characterization tests around behavior
  2. Small commits: extract → rename → move
  3. Preserve external behavior; use feature flags for risky swaps
  4. Delete dead code in same PR when safe

See references/refactoring_quality.md for smells and safe sequences.

5. Reliability and performance

Reliability defaults:

  • Timeouts on all outbound calls
  • Retries with jitter only for idempotent ops
  • Circuit breakers at integration boundaries
  • Graceful degradation with clear user messaging

Performance:

  1. Measure (profiler, traces, query plans)—no premature optimization
  2. Fix N+1, unnecessary allocation, hot loops
  3. Cache with explicit TTL and invalidation story

See references/reliability_patterns.md for distributed systems primitives.

6. Technical leadership
  • Unblock others: pair on hard bugs, clarify design decisions in writing
  • Raise risks early; propose phased delivery
  • Document decisions in ADR when reversal is costly
  • Align with product on scope vs quality trade-offs

See references/rfc_technical_leadership.md for ADRs and mentoring prompts.

When to load references

  • Service design and RFCs → references/system_design.md
  • PR review → references/code_review.md
  • Refactoring → references/refactoring_quality.md
  • Reliability and performance → references/reliability_patterns.md
  • Estimation, ADRs, mentoring → references/rfc_technical_leadership.md

Comments

Markdown supported