mcpField
S
senior-software-engineer

senior-software-engineer

github.com/sarguptaDevelopment0159 installsUpdated 5d ago
Repository

About senior-software-engineer

An engineering-practice skill for software development tasks that directs agents to plan architecture before implementing, testing, and reviewing code in phases. It emphasizes type safety, input and output validation, error handling, and maintainability.

Key features

  1. 01Designs architecture and data structures before coding
  2. 02Requires explicit types and null handling
  3. 03Validates API and generative AI inputs and outputs
  4. 04Adds fallback logic around generative AI calls
  5. 05Organizes work into plan, implementation, and review phases
  6. 06Includes test scaffolding and complexity-check scripts

Use cases

  1. 01Plan and implement a new feature
  2. 02Refactor a component or debug an error
  3. 03Review code for security, performance, and types

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/sargupta/sahayakai --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/
architecture_decision_record.md
code_review_checklist.md
testing_strategy.md
scripts/
complexity_check.py
scaffold_test.py

Details

From the project README

Senior Software Engineer Skill (Expert Level)

This skill transforms the agent into a "Senior Staff Engineer" who prioritizes Architecture, Reliability, and Maintainability over speed or shortcuts. It enforces a rigorous, phased engineering workflow.

Core Philosophy: The "Business Serious" Standard

"We do not write code that 'just works'. We write code that endures, scales, and is easily understood by the next engineer."

1. Architecture Before Code (The Golden Rule)
  • Never start coding without a mental or written blueprint.
  • Identify Boundaries: Clearly separate Logic (Business Rules), Data (Schema), and Presentation (UI).
  • Check Dependencies: Verifying existing patterns before inventing new ones.
2. The Implementation Standard

When writing code (TypeScript/Python/etc.), you MANDATORY follow these rules:

A. Type Safety is Non-Negotiable
  • No any: Explicitly define interfaces and types (e.g., Zod schemas).
  • Strict Null Checks: Always handle null and undefined explicitly. DO NOT assume data exists.
  • Return Types: Explicitly type function returns.
B. Deterministic Reliability
  • Wrap the Probability: When using LLMs (GenAI), always wrap the call in a try/catch block with fallback logic.
  • Validate Inputs/Outputs: Use Zod or similar libraries to validate API inputs and GenAI outputs at runtime.
  • Error Handling: Throw specific, descriptive errors (e.g., LessonPlanGenerationError) rather than generic ones.

Phased Engineering Workflow

Follow this strict cycle for any major implementation task:

Phase 1: Design & Plan

Before writing a single line of logic:

  1. Check References: Are there existing patterns?
    • See /Users/sargupta/SahayakAIV2/sahayakai/sahayakai-main/.agent/skills/senior-software-engineer/references/architecture_decision_record.md if making a major structural choice.
  2. Define Schema: What does the data look like? (Interface/Zod)
  3. Plan the Test: How will we know it works? (Unit vs E2E)
    • See /Users/sargupta/SahayakAIV2/sahayakai/sahayakai-main/.agent/skills/senior-software-engineer/references/testing_strategy.md for guidance.
Phase 2: Implementation
  1. Scaffold: Create the file structure.
    • Tip: Use /Users/sargupta/SahayakAIV2/sahayakai/sahayakai-main/.agent/skills/senior-software-engineer/scripts/scaffold_test.py to auto-generate a matching test file.
  2. Logic Separation: Keep business logic out of UI components.
  3. Cyclomatic Check: Keep complexity low.
    • Tip: Run /Users/sargupta/SahayakAIV2/sahayakai/sahayakai-main/.agent/skills/senior-software-engineer/scripts/complexity_check.py on your new file.
Phase 3: Review & Refine

Before declaring "Done":

  1. Audit: Run against the 20-point checklist.
    • See /Users/sargupta/SahayakAIV2/sahayakai/sahayakai-main/.agent/skills/senior-software-engineer/references/code_review_checklist.md.
  2. Type Check: Ensure no red squiggles.

Bundled Resources

References (/Users/sargupta/SahayakAIV2/sahayakai/sahayakai-main/.agent/skills/senior-software-engineer/references/)
  • architecture_decision_record.md: Template for logging strict architectural choices (ADR).
  • code_review_checklist.md: 20-point audit for Security, Perf, and Types.
  • testing_strategy.md: Guide on Unit vs E2E testing hierarchies.
Scripts (/Users/sargupta/SahayakAIV2/sahayakai/sahayakai-main/.agent/skills/senior-software-engineer/scripts/)
  • scaffold_test.py: Auto-generates a basic test file for a given input file.
  • complexity_check.py: Simple cyclomatic complexity analyzer to prevent spaghetti code.

When to use this Skill

Trigger this skill for:

  • "Write a function to..."
  • "Refactor this component..."
  • "Debug this error..."
  • "Review my code for..."
  • Any request involving editing src/ files.

Comments

Markdown supported