thapaliyabikendra
- 57 skills
- 0 followers
- 7 hours ago last updated
- ▌ Compiler 2 · thapaliyabikendraArchitectural Compiler for a microservice DDD wiki. Transforms FRS documents (via GitLab) into a persistent, compounding Domain-Driven Design knowledge graph. Generates Feature Specs, GitLab Issues, Test Plans, Test Runs, Topologies, Changelogs, and API Release Docs. Operates across four roles: Spec Compiler (Agent), BA, Developer, and QA.
- ▌ Review Frs 2 · thapaliyabikendraYou MUST use this when the user asks to review, audit, validate, lint, or check existing Functional Requirements Specifications. Triggers on: reviewing a GitLab FRS issue, auditing a milestone's worth of FRS, validating a pasted FRS, checking an uploaded FRS file (.md/.docx/.pdf), or any phrase like 'is this FRS correct', 'check my FRS', 'audit these requirements', 'validate the FRS'. Fires whether the user wants findings only or findings with proposed fixes. For generating NEW FRS from prose / code / notes, use skill:generate-frs instead.
- ▌ Generate Test Plan 2 · thapaliyabikendraManages all reads and writes to per-TC Markdown files in plans/{feature}/{feature}-TC-NNN.md. Replaces state-manager. Use this skill whenever any agent needs to read TC status, create a new TC file, or update a specific field. Never overwrite a TC file entirely — always patch specific fields.
- ▌ Generate Frs 2 · thapaliyabikendraYou MUST use this when the user asks to generate Functional Requirements Specifications, break a product/feature/system into business modules, turn meeting notes or rough briefs into formal requirements, or sync requirements to GitLab as milestones and issues. Triggers on keywords: FRS, BRS, functional requirements, business requirements, spec doc, module breakdown, GitLab milestone sync. Fires even when input is rough — the skill infers structure. Accepts prose, React/TS components, and uploaded files. For reviewing existing FRS, use skill:review-frs instead.
- ▌ Generate Test Suite 2 · thapaliyabikendra bundleConverts a parsed QA scenario and selector map into a Playwright TypeScript test() function. Use this skill whenever generating, writing, or regenerating Playwright test code from spec steps and selectors. Always invoke during Phase 3 script generation or when a single test needs to be regenerated after a selector update during retry.
- ▌ Compiler · thapaliyabikendra bundleUse for FRS-to-DDD compilation, artifact generation, architecture queries, conflict resolution (CNF/DFB), or milestone closure. Symptoms: need traceability from FRS to Feature Specs, version drift detection, Shadow QA duplication prevention, non-monolithic FRS enforcement, or home.md >150 nodes. Keywords: FRS ingestion, ABSORB compilation pass, DDD nodes (ACT/ENT/CMD/FLOW/STATE), CNF blocking, DFB feedback, version bump rules, deprecation propagation, 6-gate milestone closure, immutable sources, Shadow QA wikilinks, LINT debt (30 classes), TRUN sign-off required, SYNTHESIZE 3-bar quality gate, brownfield init, scenario gap hard gate.
- ▌ Post Issues · thapaliyabikendraReads a compiled FEAT- node and posts it to GitLab as a parent issue with one child issue per task, all linked to the correct milestone. Can be invoked manually or automatically by COMPILE when role=BA. When invoked by COMPILE, accepts pre-resolved context and skips status check.
- ▌ Fetch Gitlab Issues · thapaliyabikendraFetches GitLab issues and saves them as Markdown FRS documents under raw_sources/. Annotates source_type and monolith signals for downstream INGEST processing.
- ▌
- ▌
- ▌
- ▌ Review Frs · thapaliyabikendraAudit an existing Functional Requirements Specification (FRS) against the canonical validation contract: structural completeness, Skill Constraint minimums, Self-Review checklist, NFR rubric, Bundling Detection, AC↔FR traceability, glossary resolution, cross-cutting-concerns non-duplication. Reads, never writes. For generating new FRS, use skill:generate-frs. Trigger phrases: review FRS, audit FRS, FRS quality, FRS check, validate spec, FRS findings.
- ▌ Generate Frs · thapaliyabikendra bundleGenerate Functional Requirements Specifications (FRS / BRS) from prose, code, or files: classify sources, break into business modules, draft business-language FRS against the canonical section structure, sync approved specs to GitLab as milestones and issues. Module-batched orchestrator with three context-discipline moves (no inline FRS bodies, batched OQs, module-boundary disposition). For reviewing existing FRS, use skill:review-frs. Trigger phrases: FRS, BRS, functional requirements, business requirements, spec doc, module breakdown, GitLab milestone sync.
- ▌ Dom Mapper · thapaliyabikendra bundleMaps semantic element names from QA specs to real CSS selectors by analysing a live DOM snapshot. Use this skill whenever exploring a page to find selectors for test automation, building or updating a selector map, or when AGENT_explorer needs to identify interactive elements. Always invoke when given a DOM snapshot and a list of target names that need CSS selectors.
- ▌ Implement Feat · thapaliyabikendra bundleDeterministic ABP code generation from a wiki-published Feature Specification, grounded in a prior scan of the repository. Reconnoitres the solution for existing DTOs, entities, AppServices, background workers, hosted services, hubs and event handlers; reconciles them against the Feat Spec into REUSE / UPDATE / CREATE / CONFLICT; writes code only after two user approval gates. Enforces ABP quality gates (no controllers, DomainService over ILocalEventBus cross-aggregate, exception handling, naming, dynamic sorting, select-before-fetch mapping, DeleteAsync soft-delete, ModelBuilder EF Core config, structured logging, implicit tenant scoping). Commands realize as AppService / BackgroundJob / IHostedService / SignalR Hub / EventHandler / CLI per FS Execution-model declaration plus repo evidence — not AppService-only. Migrations remain manual.
- ▌ Auth Handler · thapaliyabikendraValidates or creates a Playwright authentication session before page exploration begins. Use this skill whenever the QA explorer agent needs to access authenticated routes, when setup/auth.json is missing or expired, or when a test fails with an unexpected redirect to the login page mid-run. Always invoke at the start of Phase 2 exploration before any page navigation.
- ▌ Task Planner · thapaliyabikendraInvoked automatically when the user wants to plan a project, feature, or complex task. Triggers on phrases like "plan this", "help me plan", "break this project into tasks", "create a development plan", "what are the steps to build", or any request to organise work before coding begins. Produces a structured, actionable plan with phases, milestones, and prioritised tasks.
- ▌ Analyze Story · thapaliyabikendraParses a user story .md file into structured data. Use this skill whenever reading user story files from STORIES_DIR. Always invoke from spec-parser at Phase 1.
- ▌
- ▌ Domain Design · thapaliyabikendra bundleDesign bounded contexts, aggregates, and domain events from an approved FRS GitLab issue. Dispatches domain-analysis-agent for DDD analysis. Produces Layer 2 DDD docs locally. Use when user says "domain model", "bounded context", "DDD design", "aggregate", or "BC mapping". Phase 3 of the agentic development workflow.
- ▌ Task Breakdown · thapaliyabikendraInvoked automatically when the user asks to break down a single task, user story, or feature into smaller sub-tasks or implementation steps. Triggers on phrases like "break this down", "how do I implement", "sub-tasks for", "expand this task", "what are the steps for", or when a task seems too large to be actionable. Produces a granular, ordered checklist ready to be picked up by a developer.
- ▌ Generate Feat Spec · thapaliyabikendra bundleGenerate a high-level technical Feature Specification (Feat Spec) from Functional Requirement Specification (FRS) issues in a GitLab milestone. Produces an ABP-layered spec in the wiki and a lightweight coordination issue in GitLab.
- ▌ Generate Test Plan · thapaliyabikendra bundleUse when a QA engineer needs a test plan generated from an FRS document or raw application code — NOT from user stories. Walks every structured section of the FRS (Functional Requirements, Acceptance Criteria, Main Flow, Alternative Flows, Exception Flows, Edge Cases, Business Rules, Notifications, Form Fields), auto-generates implicit TCs the source leaves unstated (validation, cross-field rules, state transitions, modal/view interactions, session edge cases, multi-tenancy, authorization, concurrency), AND populates a per-TC Test Data section with concrete or templated values derived from each field's constraints. Produces TC files in the docs/wiki repo at {docs_repo}/test-plans/{feature}/{use-case}/{feature}-TC-NNN.md, with each TC tracing back to its FR-ID / AC-ID / BR-ID / EC-ID / matrix row so coverage is auditable. The skill auto-discovers the docs/wiki repo (sibling lookup, then grandparent lookup, then asks). FRS input → placeholder selectors; raw-code input → selectors extracted from code. Test Data
- ▌ Spec Generation · thapaliyabikendraConverts raw requirements (notes, briefs, bullet points, or a requirements file) into a structured Feature Specification document. Input is either a file path or inline text. Output is a .md feature spec file saved to docs/specs/{feature-name}/. Use this skill whenever someone provides requirements and wants to produce a feature spec, says "write a spec for this", "turn this into a feature spec", or provides a requirements file and wants it structured.
- ▌ Task Generation · thapaliyabikendraConverts one or more User Story files into a High-Level Technical Task Plan. Reads each story, breaks it down into implementation tasks grouped by layer (backend, frontend, integration, notifications, config, testing), assigns estimates, and links every task back to its source story. Each task is saved as its own file directly inside docs/feat/{feature-name}/ as T-001.md, T-002.md, etc. A combined plan summary is also written. No code snippets are produced — only task descriptions. Use this skill whenever someone says "generate tasks from this story", "break this into tasks", "create a technical plan for this", or provides user stories and wants implementation tasks produced.
- ▌ Generate Test Suite · thapaliyabikendra bundleConverts TC files from the docs/wiki repo at {docs_repo}/test-plans/ into Playwright TypeScript test files in the tests repo at {tests_repo}/{test_dir}/. Auto-discovers both repos (sibling → grandparent → ask), reads playwright.config to find the test directory, then asks the user how to handle the branch — write to current branch, create a test/{feature-name} branch from current, or create one from a different source — and writes one spec file per use case sub-folder. Use when generating, writing, or regenerating Playwright test code from the test plan.
- ▌ Dependency Mapper · thapaliyabikendraInvoked automatically when the user wants to understand task ordering, identify blockers, or visualise dependencies between tasks or modules. Triggers on phrases like "what depends on what", "task order", "what should I do first", "dependency graph", "critical path", "what blocks what", or "execution order". Produces an ordered execution sequence and highlights the critical path.
- ▌ Release Readiness · thapaliyabikendra bundleScore release readiness against the Definition of Done, generate release notes, and produce a readiness report. Use when user says "release notes", "release readiness", "ready to release", "final review", or "publish". Phase 8 of the agentic development workflow.
- ▌ Fetch Gitlab Issue · thapaliyabikendraFetches one or more GitLab issues by ID and displays them in Markdown format. Can also fetch linked issues. Simple, focused on output.
- ▌ Post Gitlab Issues · thapaliyabikendraReads User Story files (US-001.md, US-002.md) and Task files (T-001.md, T-002.md) from a feature folder under docs/feat/{feature-name}/ and creates GitLab issues for each one. User stories are posted as issues with their scenarios and acceptance criteria. Tasks are posted as issues linked back to their source user story issue. Reads project context (project ID, allowed labels, available users) from CLAUDE.md. Use after feature-spec-to-user-stories and user-stories-to-tasks have produced files and you want everything tracked in GitLab.
- ▌ Requirement To Frs · thapaliyabikendra bundleUse when converting raw requirements, BRDs, or feature ideas into a comprehensive Functional Requirements Specification (FRS) with 17 sections, tiered complexity assessment, and downstream readiness scoring. Phase 1 of agentic-dev-flow pipeline. Trigger phrases: "write FRS", "requirement to FRS", "create FRS", "intake requirements". Symptoms: ambiguous requirements, unclear scope, missing actors, vague acceptance criteria.
- ▌ Feature Specification · thapaliyabikendra bundleGenerates a Feature Specification with user stories and acceptance criteria from an approved FRS GitLab issue and domain design docs. Posts result as a GitLab Feature Spec issue. Use when user says "feature spec", "user stories", "acceptance criteria", or "write feature". Phase 4 of the agentic development workflow.
- ▌ Validation Acceptance · thapaliyabikendra bundleGenerate a test plan and acceptance test results from a Feature Spec GitLab issue. Dispatches qa-agent for test generation. Produces TEST_PLAN.md and ACCEPTANCE_RESULTS.md. Use when user says "validate", "acceptance test", "test plan", "QA", or "test coverage". Phase 6 of the agentic development workflow.
- ▌ Workflow Orchestrator · thapaliyabikendraChain all 7 phase skills in order, enforcing human approval gates between each phase. Entry point for the complete 8-phase agentic delivery pipeline. Use when user says "full workflow", "8-phase", "start from requirements", "run workflow", or "end-to-end delivery".
- ▌ Milestone Traceability · thapaliyabikendraBuild a traceability matrix across all phase artifacts and create the GitLab milestone, epic, and story issues. Use when user says "milestones", "traceability", "push to gitlab", "track milestone", or "create issues". Phase 7 of the agentic development workflow.
- ▌
- ▌ User Stories Generator · thapaliyabikendraConverts a Feature Specification or raw requirements into one or more structured User Story files. Reads the input, determines how many user stories are needed based on the number of distinct actors and actions, and generates each story with scenarios and acceptance criteria. Stories are saved directly inside docs/feat/{feature-name}/ as US-001.md, US-002.md, etc. Use this skill whenever someone says "write user stories for this", "generate stories from this spec", "turn this into user stories", or provides a feature spec or requirements and wants user stories produced from it.
- ▌ Implementation Execution · thapaliyabikendraExecutes implementation from an approved Feature Spec GitLab issue by dispatching implementation-agent for code generation. Internal task decomposition is NEVER persisted as GitLab issues. Use when user says "implement", "build", "generate code", "execution plan", or "code this feature". Phase 5 of the agentic development workflow.
- ▌ Authoring Skills For Claude Code · thapaliyabikendra bundleYou MUST use this when creating, editing, or auditing a Claude Code skill. Covers orchestrator, reference, workflow, forked-context, subagent-dispatching, background, and memory-backed skills. Required before writing any SKILL.md body.
- ▌ Linq Optimization Patterns · thapaliyabikendra bundleLINQ and EF Core query optimization for ABP Framework. N+1 prevention, eager loading, projections, pagination.
- ▌ Postgresql Query Generation · thapaliyabikendra bundleGenerate optimized PostgreSQL queries for Entity Framework Core projects. Automatically discovers domain entities, relationships, and conventions to produce production-ready SQL. Use when: 1. You need complex PostgreSQL queries across multiple related entities 2. Working with ABP Framework and need multi-tenancy/soft delete patterns 3. Querying JSONB fields or need recursive CTEs 4. Building analytics/reporting queries with window functions 5. Optimizing existing queries with proper indexes and joins.
- ▌ Authentication Authorization Patterns · thapaliyabikendra bundleMaster authentication and authorization patterns including OAuth 2.0, OpenID Connect, JWT tokens, refresh tokens, role-based access control (RBAC), claims-based authorization, and secure token storage for .NET applications with OpenIddict and ABP Framework.
- ▌ Data Seeder Generator · thapaliyabikendraGenerate ABP Framework data seeder contributors following project conventions. Auto-detects project structure, existing entities, namespaces, permission constants, and seeder patterns from the codebase — no manual configuration needed. Creates IDataSeedContributor implementations with proper dependency injection, logging, and tenant/feature awareness. Use when: (1) creating new seed data for entities, (2) adding initial/reference data, (3) scaffolding data initialization code, (4) maintaining data consistency across environments.
- ▌ Generating Tests · thapaliyabikendra bundleGenerates xUnit tests for C#/.NET ABP Framework code using NSubstitute and Shouldly. Use when the user asks to generate tests, create test coverage, write unit tests, write integration tests, fill coverage gaps, or test a class or file. Supports AppServices, Validators, and HTTP API Controllers.
- ▌ Security Patterns · thapaliyabikendraWeb application security patterns including STRIDE threat modeling, OWASP Top 10 compliance, ABP authorization, and security audit procedures. Use when: (1) conducting security audits, (2) implementing authentication/authorization, (3) creating threat models, (4) reviewing code for vulnerabilities.
- ▌ Requirements Gap Filler · thapaliyabikendraChecks requirements.md against the actual codebase to find ALL four types of gaps — requirements missing from code, requirements partially implemented, code logic not mentioned in requirements, and business rules in code that were never written into requirements. Automatically updates requirements.md in both directions — flags unimplemented requirements AND adds newly discovered code logic back into requirements. Use after code generation to keep requirements fully in sync with what was actually built.
- ▌ API Spec To Service · thapaliyabikendraGenerate ABP ApplicationService, DTOs, interfaces, and API release documentation from Markdown or OpenAPI/Swagger API specifications. Works with ANY ABP project by auto-detecting existing patterns (response wrappers, error handling, validation, authorization). Use when the user provides an API spec and wants to scaffold services that match their project's conventions and generate release notes.
- ▌ Test Data Generation · thapaliyabikendraTest data generation patterns using Bogus, test builders, and ABP seeders. Use when: (1) creating realistic test data, (2) implementing test data seeders, (3) building test fixtures, (4) generating fake data for development.
- ▌ Dotnet Async Patterns · thapaliyabikendra bundleMaster .NET async/await patterns including Task-based Asynchronous Pattern (TAP), ValueTask optimization, ConfigureAwait usage, cancellation tokens, parallel processing, and avoiding deadlocks in ASP.NET Core applications for maximum performance and responsiveness.
- ▌ Host Module Configuration · thapaliyabikendraConfigure an ASP.NET Core ABP Framework HttpApiHost or Web host module for production-ready infrastructure. Use when the user requests host-level configuration, middleware pipeline changes, Swagger/OpenAPI wiring, health checks, reverse proxy support, CORS, Hangfire dashboard, API versioning, forwarded headers, feature-flagged host behavior, or related host module and middleware registration updates.
- ▌ User Stories To API Spec · thapaliyabikendra bundleConverts requirements written as user stories (.md or .txt) into a structured API Specification document. Defines REST endpoints, request/response shapes, status codes, and permissions for each user story. Output is a .md api-spec file ready to feed into the api-spec-to-technical-plan skill. Use when you have user stories and want a clear API contract before any technical planning or code generation begins.
- ▌ Abp Framework Patterns · thapaliyabikendra bundleMaster ABP Framework patterns including repository pattern, unit of work, domain services, application services, authorization, multi-tenancy, background jobs, and distributed events. Use when: (1) building ABP-based applications with DDD architecture, (2) creating CRUD services with Entity, AppService, DTOs, validators, (3) handling authorization/permissions, (4) generating ABP module code.
- ▌ Code Review Excellence · thapaliyabikendraMaster effective code review practices to provide constructive feedback, catch bugs early, and foster knowledge sharing while maintaining team morale. Use when reviewing pull requests, establishing review standards, or mentoring developers.
- ▌ Git Advanced Workflows · thapaliyabikendraMaster advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Use when managing complex Git histories, collaborating on feature branches, or troubleshooting repository issues.
- ▌ Crud Generator · thapaliyabikendraGenerate complete CRUD application services for ABP Framework following DDD patterns. Creates interface in Contracts layer, implementation in AppServices, and DTOs in Contracts. Use when: (1) creating new entity services, (2) scaffolding CRUD operations, (3) implementing standard ABP service patterns, (4) accelerating feature development.
- ▌ Abp Integration Testing · thapaliyabikendraGenerate integration tests for ASP.NET Core ABP Framework application services and HTTP APIs. Use when the user requests integration tests, end-to-end tests, API tests, or wants to verify ABP framework integration points (repositories, authorization, validation, multi-tenancy, unit-of-work, data filters). Trigger even if the user just says "add tests" for an ApplicationService — ask if they want unit or integration tests.
- ▌ Ef Core Advanced Patterns · thapaliyabikendra bundleMaster Entity Framework Core advanced patterns including change tracking optimization, lazy/eager/explicit loading strategies, query splitting, compiled queries, batch operations, optimistic concurrency, performance optimization, and PostgreSQL-specific features for .NET applications.