movie-theater-tickets

This skill should be used when the user wants to generate requirements.md for a slice. Trigger when the user invokes /feature-requirements, says "formalize the requirements", or asks for the F/N traceability after plan.md exists. Reads prd.md and plan.md. Produces requirements.md only — formal functional (F) and non-functional (N) requirements with IDs that the validation and tests phases trace back to.

This skill should be used when the user wants to generate tests.md for a slice. Trigger when the user invokes /feature-tests, says "write outside-in test spec", or asks to describe the slice-level integration test in markdown form before any code is written. Use only after prd.md, plan.md, requirements.md, validation.md exist. Produces markdown specification only; does not write C# code.

This skill should be used when the user wants to generate validation.md for a slice. Trigger when the user invokes /feature-validation, says "write the validation checklist", or asks for manual scenarios after requirements.md exists. Reads prd.md, plan.md, requirements.md. Produces validation.md with manual scenarios and code review checklist.

This skill should be used when the user wants to generate the executable C# outside-in test for a slice from its tests.md specification. Trigger when the user invokes /slice-test-red, says "generate the red test", "write the outside-in C# test", or asks to translate tests.md into a runnable xUnit test class. Use only after tests.md exists. Reads tests.md plus architectural context, writes <Slice>OutsideInTests.cs, runs dotnet test, and verifies the test is RED.

This skill should be used when the user references slice spec work, mentions a slice folder (specs/features/...), asks "what's next" on a slice, or invokes the spec chain. It auto-loads the architectural context, inspects the current slice folder, determines which stage the slice is in, and advises which command to run next. This skill advises only; it does not write spec files itself.

Structure Flutter apps using layered architecture (UI / Logic / Data) with feature-first file organization. Use when creating new features, designing the project folder structure, adding repositories, services, view models (or cubits/providers/notifiers), wiring dependency injection, or deciding which layer owns a piece of logic. State management agnostic.

Implement Flutter state management using the bloc and flutter_bloc libraries. Use when creating a new Cubit or Bloc, modeling state with sealed classes or status enums, wiring BlocBuilder/BlocListener/BlocProvider in widgets, writing bloc unit tests, refactoring state management, or deciding between Cubit and Bloc.

This skill should be used whenever the user works with state management in this Flutter project — creating or modifying a Cubit, a Bloc, a state class, or a use-case that a Cubit orchestrates. Trigger on mentions of Cubit, Bloc, "state for the screen", `flutter_bloc`, sealed state, freezed state, "loading state", "error state", "emit state", `bloc_test`, or any phrase implying that the application layer of a slice is being touched. Also trigger when the user asks how a screen should react to a server response, how to surface loading/error in the UI, or how to wire a button press to an async operation. Do not trigger for pure UI/widget work that does not change state shape.

Review Flutter/Dart pull requests and merge requests against a structured checklist. Use when asked to review a PR, review a MR, review a branch, audit changed files, check code quality, or evaluate a diff. Covers correctness, security, performance, style, testing, and documentation.

Apply Dart 3 language features including patterns, sealed classes, switch expressions, records, and if-case syntax. Use when writing switch statements, refactoring if-else chains, creating data classes, choosing between records and classes, destructuring values, or modernizing pre-Dart-3 code.

Apply Effective Dart guidelines to write idiomatic, high-quality Dart and Flutter code. Use when writing new Dart code, reviewing pull requests for style compliance, refactoring naming conventions, adding doc comments, structuring imports, enforcing type annotations, or running code review checks against Effective Dart standards.

This skill should be used when the user wants to generate requirements.md for a slice in this Flutter project. Trigger when the user invokes /feature-requirements, says "write requirements", "generate requirements doc", "fill in requirements for the slice", or asks to formalize functional and non-functional requirements after a PRD and plan already exist. Use this skill only after both prd.md and plan.md exist for the target slice — it reads both as input.

This skill should be used when the user wants to generate tests.md for a slice in this Flutter project. Trigger when the user invokes /feature-tests, says "write outside-in test spec", "generate tests.md", or asks to describe the slice-level integration test in markdown form before any code is written. Use this skill only after prd.md, plan.md, requirements.md, and validation.md all exist for the target slice — it reads all four as input. This skill writes a markdown specification only; it does NOT write Dart code.

This skill should be used when the user wants to generate validation.md for a slice in this Flutter project. Trigger when the user invokes /feature-validation, says "write validation checklist", "generate validation doc", "fill in validation for the slice", or asks to produce a manual test plan and code review checklist after PRD, plan, and requirements already exist. Use this skill only after prd.md, plan.md, and requirements.md all exist for the target slice — it reads all three as input.

Implement layered Flutter app architecture with MVVM, repositories, services, and dependency injection. Use when scaffolding a new Flutter project, refactoring an existing app into layers, creating view models and repositories, configuring dependency injection, implementing unidirectional data flow, or adding a domain layer for complex business logic.

Diagnoses and fixes common Flutter errors. Use when encountering layout errors (RenderFlex overflow, unbounded constraints, RenderBox not laid out), scroll errors, or setState-during-build errors.

Uses the Mocktail package for mocking in Flutter/Dart tests. Use when creating mocks, stubbing methods, verifying interactions, registering fallback values, or deciding between mocks, fakes, and real objects.

This skill should be used at the start and at the end of work on any feature or slice in this project. Trigger when the user says "new feature", "new slice", "start a feature", "start working on", "spec for X", "let's plan X", "I want to add X functionality", or anything that signals the beginning of a non-trivial change. Also trigger at the end — phrases like "I'm done with X", "finished implementing", "wrap up the slice", "this slice is ready", or when a slice's tests pass and the conversation is winding down. This skill walks the user through the procedure for `specs/`, `roadmap.md`, and `.claude/decisions/`. Make sure to use this skill even if the user does not explicitly ask for it — they often forget the bookkeeping, and missing it breaks the project's memory.

Run full feature-spec→feature-requirements→feature-validation→feature-tests→slice-test-red pipeline for a feature folder

This skill should be used whenever the user is deciding how to organize new functionality in the project — whether something is a new slice, an extension of an existing slice, a separate feature, or a piece of `_shared/` code. Trigger on phrases like "new feature", "new slice", "where should I put", "should this be its own slice", "split this slice", "extend this slice", "add to feature X", "decompose", "organize this functionality", "list with filtering", "edit screen", "delete operation", or any planning conversation that mentions multiple operations or screens within one feature. Also trigger when the user describes a new screen and you need to decide which slice it belongs to. This is a planning/decision skill — invoke it before code is written, not while writing code.

This skill should be used when the user wants to generate the executable Dart outside-in test for a slice from its tests.md specification. Trigger when the user invokes /slice-test-red, says "generate the red test", "write the outside-in Dart test", "make the failing test", or asks to translate tests.md into runnable Dart code. Use this skill only after tests.md exists for the target slice — it reads tests.md plus architectural context as input, produces a Dart test file, and runs `flutter test` to verify the test is RED (fails as expected because the implementation is not yet written).

This skill should be used at the start of any work on a slice specification in this Flutter project — when the user wants to create a new spec, continue an in-progress spec, or is unsure which step comes next. Trigger on phrases like "let's work on a spec", "start a new slice", "next spec step", "help with the spec", "what's next on this slice", "I want to add functionality X", or any phrase indicating spec work without naming a specific spec command. Also trigger when the user invokes /spec-workflow explicitly. This skill is a dispatcher — it loads architecture context, inspects the slice folder, and tells the user which of the four spec commands to run next. It does not produce any of the four spec files itself.

Write, review, and improve Flutter and Dart tests including unit tests, widget tests, and golden tests. Use when writing new tests, reviewing test quality, fixing flaky tests, adding test coverage, structuring test files, or choosing between unit and widget tests.

Turn the current conversation context into a PRD and publish it to the project issue tracker. Use when user wants to create a PRD from the current context.

Analyzes codebase implementation details. Call the codebase-analyzer agent when you need to find detailed information about specific components. As always, the more detailed your request prompt, the better! :)

Use this skill when implementing a DB-only slice — one that adds or changes EF Core entities, IEntityTypeConfiguration<T>, and an EF Core migration, but has no MediatR command/query handler or HTTP endpoint. Trigger when plan.md says "no use-case" and "no HTTP entry point", or when the user says "implement the DB foundation slice".

This skill should be used when the user wants to generate plan.md for a slice. Trigger when the user invokes /feature-spec, says "write the plan", "spec out this slice", or asks for the implementation plan after prd.md exists. Reads prd.md plus architectural context plus the nearest reference slice. Produces plan.md only.

This skill should be used when the user asks about the project's history, asks where a decision is recorded, or wants to know how to record a new one. It points to the roadmap, ADRs, and per-slice spec folders as the project's three forms of memory, and explains who writes to each.

Run full feature-spec→feature-requirements→feature-validation→feature-tests→slice-test-red pipeline for a feature folder

This skill should be used when the user is splitting a new feature into slices, when a planned slice feels too large, or when the user asks "should this be one slice or two?". It helps decide the right grain of decomposition — each slice is one MediatR command or query use-case, one repository, one HTTP entry point.

Turn the current conversation context into a PRD and publish it to the project issue tracker. Use when user wants to create a PRD from the current context.