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.