diff --git a/.github/prompts/README.md b/.github/prompts/README.md
index ca0fec9..ffe734e 100644
--- a/.github/prompts/README.md
+++ b/.github/prompts/README.md
@@ -9,6 +9,10 @@ This directory contains reusable prompt files that extend Copilot Chat with repe
 - [/write-docs](write-docs.prompt.md)
 - [/write-ears-spec](write-ears-spec.prompt.md)
 - [/write-prd](write-prd.prompt.md)
+- [/plan-onboard.prompt.md](plan-onboard.prompt.md)
+- [/plan-create.prompt.md](plan-create.prompt.md)
+- [/plan-update.prompt.md](plan-update.prompt.md)
+- [/plan-exec.prompt.md](plan-exec.prompt.md)
 
 ## How to use
 - In Copilot Chat, type the prompt name or pick it from the quick actions list.
diff --git a/.github/prompts/plan-create.prompt.md b/.github/prompts/plan-create.prompt.md
new file mode 100644
index 0000000..9f921e6
--- /dev/null
+++ b/.github/prompts/plan-create.prompt.md
@@ -0,0 +1,70 @@
+---
+mode: 'agent'
+description: 'Plan feature implementation or bug fix and store it in a markdown file in the .ai folder'
+tools: ['codebase', 'search', 'searchResults', 'changes', 'findTestFiles', 'terminalSelection', 'terminalLastCommand', 'editFiles', 'fetch', 'runCommands']
+---
+
+<!-- Create action plan prompt is a part of Onboard, Plan and Execute method applicable for software engineering tasks using AI Agent. 
+
+* Its goal is to generate action plan document based on a feature/requirement description. In result, plan will contain elaboration on purpose, list of self reflecting and open questions (open questions should be answered using `plan-update` prompt). Plan should be reviewed and refined, also via `plan-update` prompt).
+
+* Recommended models: Claude Sonnet 4+
+
+* How to use it: use agent mode, choose one of the recommended models, launch prompt via `/plan-create <requirement specification>`. Pass brief requirement specification as a parameter to the prompt.
+
+DISCLAIMER: this prompt is derived from 10xdevs training (https://www.10xdevs.pl/)
+-->
+
+You are an experienced software developer tasked with creating an action plan to address an issue. Your goal is to produce a comprehensive, step-by-step plan that will guide the resolution of this issue.
+
+First, review the following information:
+
+<issue_description>
+
+${input:IssueDescription}
+
+</issue_description>
+
+Your task is to create an action plan document in Markdown format. Follow these steps, working inside <action_plan_development> tags in your thinking block. If you see <perform_action>, go outside of thinking block, perform a given action via tool call.
+
+<action_plan_development>
+
+1. Identify Relevant Codebase Parts: Based on the issue description and project onboarding document located in `.ai/onboarding.md`, determine which parts of the codebase are most likely connected to this issue. List and number specific parts of the codebase mentioned in both documents. Explain your reasoning for each.
+2. Hypothesize Root Cause: Based on the information gathered, list potential causes for the issue. Then, choose the most likely cause and explain your reasoning.
+3. Identify Potential Contacts: List names or roles mentioned in the documents that might be helpful to contact for assistance with this issue. For each contact, explain why they would be valuable to consult.
+4. Self-Reflection Questions: Generate a list of questions that should be asked to further investigate and understand the issue. Include both self-reflective questions and questions for others. Number each question as you write it.
+5. Next Steps: Outline the next steps for addressing this issue, including specific actions for logging and debugging. Provide a clear, actionable plan. Number each step and provide a brief rationale for why it's necessary.
+
+</action_plan_development>
+
+
+After completing your analysis, create a Markdown document with the following structure:
+```markdown
+# Action Plan for [Issue Name]
+
+## Issue Description
+[Briefly summarize the issue]
+
+## Relevant Codebase Parts
+[List and briefly describe the relevant parts of the codebase]
+
+## Root Cause Hypothesis
+[State and explain your hypothesis]
+
+## Investigation Questions
+
+### Self-Reflection Questions
+[List self-reflection questions]
+
+### Question for others
+[List questions for others]
+
+## Next Steps
+[Provide a numbered list of actionable steps, including logging and debugging tasks]
+
+## Additional Notes
+[Any other relevant information or considerations]
+```
+
+Ensure that your action plan is comprehensive, follows a step-by-step approach, and is presented in an easy-to-read Markdown format. The final document should be named `.ai/feature-${input:IssueNumber}-${input:IssueName}-action-plan.md`.
+Your final output should consist only of the Markdown document and should not duplicate or rehash any of the work you did in the action_plan_development thinking block. 
diff --git a/.github/prompts/plan-exec.prompt.md b/.github/prompts/plan-exec.prompt.md
new file mode 100644
index 0000000..2b239ba
--- /dev/null
+++ b/.github/prompts/plan-exec.prompt.md
@@ -0,0 +1,37 @@
+---
+mode: 'agent'
+description: 'Execute step or multiple steps from an attached action plan md file.'
+tools: ['codebase', 'search', 'searchResults', 'changes', 'editFiles', 'runCommands', 'runTests', 'findTestFiles', 'testFailure', 'fetch']
+---
+
+<!-- Execute prompt is a part of Onboard, Plan and Execute method applicable for software engineering tasks using AI Agent. 
+
+* Its goal is to execute one or more steps of the action plan, as generated by `plan-create.prompt.md` and subsequently updated with `plan-update.prompt.md`.
+
+* Recommended models: Claude Sonnet 4+, Claude Haiku 4+, Grok Code Fast 1, o4-mini
+
+* When to use: each time you want to execute one or more steps from action plan.
+
+* How to use it: use agent mode, choose one of the recommended models, launch prompt via `/plan-exec <steps>`, specify steps to execute as parameters i.e. `/plan-exec Step 1, 2`.
+-->
+
+You are an experienced software developer tasked with executing an attached action plan md file to implemented an issue.
+
+You should focus only on executing following steps, identified by their numbers, as specified in the action plan:
+
+<steps_to_execute>
+
+${input:StepsToExecute}
+
+</steps_to_execute>
+
+
+Follow the following rules during plan execution.
+
+1. When developer asks for executing plan step, it is always meant to be a step from the *next steps* section of the action plan.
+2. When developer asks for complete plan execution, execute the plan step by step but stop and ask for confirmation before executing each step
+3. When developer asks for single step execution, execute only that step
+4. When developer asks additionally for some changes, update existing plan with the changes being made
+5. Once finishing executing of the step, always mark the step as completed in the action plan by adding a ✅ right before step name.
+6. Once finishing executing the whole phase, always mark the phase as completed in the action plan by adding a ✅ right before phase name.
+7. If by any reason the step is skipped, it should be marked as skipped in the action plan by adding a ⏭️ right before step name. It should be clearly stated why it was skipped.
diff --git a/.github/prompts/plan-onboard.prompt.md b/.github/prompts/plan-onboard.prompt.md
new file mode 100644
index 0000000..6a725a5
--- /dev/null
+++ b/.github/prompts/plan-onboard.prompt.md
@@ -0,0 +1,166 @@
+---
+mode: 'agent'
+description: 'Generate project onboarding document from provided codebase, GIT history, and other relevant files.'
+tools: ['codebase', 'search', 'searchResults', 'changes', 'editFiles', 'runCommands', 'runTests', 'findTestFiles', 'testFailure', 'fetch']
+---
+
+<!-- Onboarding prompt is a part of Onboard, Plan and Execute method applicable for software engineering tasks using AI Agent. 
+
+* Its goal is to generate onboarding document that describes project purpose, history, and relevant parts.
+
+* Recommended models: Claude Sonnet 4+
+
+* When to use: this prompt should be used at least once, initially, to create `onboarding.md` file to be stored in GIT repo. After first generation, onboarding document should be mentioned in `copilot-instructions.md` via reference: `.ai/onboarding.md` to help the agent to understand the project better.
+
+* How to use it: use agent mode, choose one of the recommended models, launch prompt via `/plan-onboard`. No additional parameters needed.
+
+* Frequency of document regeneration: depending on project dynamics, one time per quarter is reasonable baseline, to be adjusted subsequently.
+
+DISCLAIMER: this prompt is derived from 10xdevs training (https://www.10xdevs.pl/)
+ -->
+
+<!-- Top level prompt with role playing and general task definition. -->
+You are an AI assistant tasked with onboarding a new developer to a big project. Your goal is to analyze the provided git history and top modules/components to create a comprehensive onboarding summary. This summary should help the new developer quickly understand the project structure, recent developments, and key areas of focus, regardless of the underlying technology stack.
+
+First, review the following information:
+
+<!-- Sets up a scope for onboarding, in this case we use GIT history to build a "heat map" of frequently modified modules. These will be analyzed first. Play with CLI parameters (like -First <n> to change the limit). You can also replace GIT CLI with static references, if you don't want to use heat map.-->
+<top_modules>
+{{top-modules}} - use GIT to get the most frequently edited modules/packages/directories in the project; example: 
+`git log --format=format: --name-only | Where-Object { $_ -ne "" } | ForEach-Object { Split-Path -Path $_ -Parent | Where-Object { $_ -ne "" } } | Group-Object | Sort-Object -Property Count -Descending | Select-Object -First 10 | Format-Table -Property Name, Count -AutoSize`
+</top_modules>
+
+<!-- Sets up a scope for onboarding, in this case we use GIT history to build a "heat map" of frequently modified files. These will be analyzed first. Play with CLI parameters (like -First <n> to change the limit). You can also replace GIT CLI with static references, if you don't want to use heat map.-->
+<top_files>
+{{top-files}} - use GIT to get the most frequently edited files in the project; example:
+`git log --since="1 year ago" --format=format: --name-only | Where-Object { $_ -ne "" } | Group-Object | Sort-Object -Property Count -Descending | Select-Object -First 20 | Format-Table -Property Name, Count -AutoSize`
+</top_files>
+
+<!-- Gathers information for most active GIT contributors. Play with CLI parameters (like -First <n> to change the limit). You can also replace GIT CLI with static references, if you don't want to use heat map. -->
+<top_contributors>
+{{top-contributors}} - use GIT to get the most active contributors in the project; example:
+`git log --format='%an' | Group-Object | Sort-Object -Property Count -Descending | Select-Object -First 10 | Format-Table -Property Name, Count -AutoSize`
+</top_contributors>
+
+<!-- Specify how to use gathered historical information. This excercise enables reasoning on purpose of recent changes, stage of the project, direction of the changes and so on. -->
+Analyze the git history and top modules/files to identify:
+1. The main areas of development focus in the past year.
+2. Frequently updated modules, directories, or core files.
+3. Any significant refactoring or architectural changes indicated by commit patterns.
+
+Based on your analysis, create an onboarding summary.
+
+**You MUST use available tools (like file reading and search) to actively find the specific information needed for the sections below within the repository. Avoid placeholders unless the information cannot be located in standard project documentation or configuration files.**
+
+**Specifically for 'Core Modules':**
+*   When describing 'Key Files/Areas' and 'Top Contributed Files' for each module/package/directory, attempt to verify file paths and roles by listing directory contents or reading key files, correlating with the provided `<top_files>` data.
+
+**Specifically for 'Development Environment Setup':**
+*   Search for and read primary project documentation files like `README` (e.g., `README.md`, `README.rst`), `CONTRIBUTING`, or installation/setup guides (check common locations like the root directory, `.github/`, or `docs/`).
+*   Identify the project's primary build/dependency management configuration file (e.g., `package.json`, `pom.xml`, `build.gradle`, `requirements.txt`, `Pipfile`, `go.mod`, `Cargo.toml`, `composer.json`, etc.). Read this file if necessary.
+*   Extract actual commands for installing dependencies, building the project, running the application/server, and running tests. Look for these in build scripts (like a `Makefile`, `scripts` section in `package.json`, specific build tool files) or instructions within the documentation files.
+*   Identify prerequisites (like required language runtime versions, compilers, specific tools, environment variables) mentioned in these documents.
+*   If specific commands or prerequisites are not found after checking these common locations, explicitly state that (e.g., "Dependency installation command not found in checked files.").
+
+**Specifically for 'Helpful Resources':**
+*   Search for and read `README`, `CONTRIBUTING`, and other documentation files (potentially in a `/docs` or similar directory if `list_dir` shows one exists).
+*   Extract actual URLs for external documentation websites, the project's issue tracker (e.g., GitHub Issues, Jira), contribution guidelines, communication channels (like Discord, Slack, mailing list links), etc., mentioned in these files.
+*   If specific links are not found, explicitly state that (e.g., "Link to communication channel not found in checked files.").
+
+To accomplish this task, you have access to the following tools:
+1. file_read: Reads the content of a specified file.
+2. file_search: Searches for files matching a given pattern.
+3. list_dir: Lists the contents of a specified directory.
+
+Generate a list of 5-7 questions that the new developer should dig into via analysing the codebase, git history and project repository (e.g., on GitHub, GitLab) to gain a deeper understanding of the project. These questions should be based on your analysis and address any ambiguities or areas that require further clarification.
+
+Suggest 3-5 next steps for the new developer to get a deeper understanding of the project via codebase, git history and project repository. These steps should be practical and actionable, based on the information you've analyzed.
+
+<!-- Below we use one-shot to precisely specify the content of generated document. -->
+Your final output should **only** include the content in markdown with the specified format that you will save in `.ai/onboarding.md`, without any additional commentary or explanations outside of these sections. Structure the output as follows, **filling it with information discovered from the repository**:
+
+```markdown
+# Project Onboarding: [Project Name Found in Repo, e.g., from README or build config]
+ 
+## Welcome
+ 
+Welcome to the [Project Name Found in Repo] project! [Brief 1-2 sentence description of what the project does and its purpose, potentially summarized from README].
+ 
+## Project Overview & Structure
+ 
+The core functionality revolves around [key functionality description, inferred from README/context]. The project is organized as [monorepo/multi-project/single application/etc.], with the following key components/modules:
+ 
+## Core Modules
+ 
+### `[Module/Package/Directory Name]`
+ 
+- **Role:** [Concise description of this component's purpose]
+- **Key Files/Areas:** 
+  - [Category/Group Name]: `path/to/file1`, `path/to/file2`, etc.
+  - [Category/Group Name]: `path/to/file3`, `path/to/file4`, etc.
+- **Top Contributed Files:** `path/to/filename`, `path/to/filename`, etc.  
+- **Recent Focus:** [Description of recent work, features, or bug fixes in this area with issue/PR references if possible to infer]
+ 
+[Repeat for each major module/package/directory based on the top_modules data]
+ 
+## Key Contributors
+ 
+- **[Contributor Name]:** [Areas of focus or expertise, key contributions based on available data]
+- **[Contributor Name]:** [Areas of focus or expertise, key contributions based on available data]
+[List top 3-5 contributors]
+ 
+## Overall Takeaways & Recent Focus
+ 
+1. **[Major Theme/Initiative]:** [Description of significant recent project-wide change based on active modules/files]
+2. **Feature Development:** [Description of recent major features added to the project, inferred from active areas]
+3. **[Specific Area] Improvements:** [Details on focused improvements in a particular active area]
+4. **UI/UX Refinement (if applicable):** [Recent UI/UX changes and improvements, inferred from relevant file activity]
+5. **Performance & Stability:** [Recent performance optimizations and stability improvements, inferred from core logic/testing activity]
+ 
+## Potential Complexity/Areas to Note
+ 
+- **[Complex Area]:** [Description of why this area might be complex (e.g., core domain logic, concurrency, state management, external system integration) and what to watch out for]
+- **[Complex Area]:** [Description of why this area might be complex and what to watch out for]
+- **[Complex Area]:** [Description of why this area might be complex and what to watch out for]
+ 
+## Questions for the Team
+ 
+1. [Question about project structure, architecture, or key design decisions]
+2. [Question about build process, deployment, or development workflows inferred from setup/docs]
+3. [Question about specific complex areas identified]
+4. [Question about data persistence, state management, or inter-service communication patterns]
+5. [Question about contributing changes to active modules or adding new features]
+6. [Question about testing strategy, code quality standards, or CI/CD pipeline]
+7. [Question about collaboration, code ownership, or release process]
+ 
+## Next Steps
+ 
+1. **[Action Item]:** [Specific details, e.g., Set up the development environment using instructions found in README]
+2. **[Action Item]:** [Specific details, e.g., Explore the `[highly_active_module/directory]` identified as highly active]
+3. **[Action Item]:** [Specific details, e.g., Run the project's test suite using the command found in the build configuration/documentation]
+4. **[Action Item]:** [Specific details, e.g., Trace a core business logic flow related to `[frequently_edited_core_file]`]
+5. **[Action Item]:** [Specific details, e.g., Review recent Pull Requests/Merge Requests related to `[another_active_module]`]
+ 
+## Development Environment Setup
+ 
+1. **Prerequisites:** [Actual prerequisites found, e.g., Language Runtime version X.Y, Compiler Z, Tool A]
+2. **Dependency Installation:** `[Actual command(s) found, or "Command not specified"]`
+3. **Building the Project (if applicable):** `[Actual command(s) found, or "Command not specified"]`
+4. **Running the Application/Service:** `[Actual command(s) found, or "Command not specified"]`
+5. **Running Tests:** `[Actual command(s) found, or "Command not specified"]`
+6. **Common Issues:** [Summarize common setup issues mentioned in docs, or state "Common issues section not found in checked files"]
+ 
+## Helpful Resources
+ 
+- **Documentation:** [Actual link(s) found, or state "Primary documentation link not found"]
+- **Issue Tracker:** [Actual link(s) found, e.g., GitHub Issues URL, Jira Project URL]
+- **Contribution Guide:** [Actual link(s) found]
+- **Communication Channels:** [Actual link(s) found, e.g., Slack invite, mailing list archive]
+- **Learning Resources:** [Actual link(s) found, or state "Specific learning resources section not found"]
+```
+ 
+Ensure that all information in the summary is based on <top_modules>, <top_files>, <top_contributors> and your exploration of the project using the provided tools. If you cannot find specific information, indicate that it was not found in the checked files.
+ 
+Your final output should consist only of the markdown-formatted onboarding summary that you will save in .ai/onboarding.md and should not duplicate or rehash any of the work you did in the exploration section of the thinking block. Finish the work after you created document with a required structure and content.
+ 
+Begin your response with your exploration.
\ No newline at end of file
diff --git a/.github/prompts/plan-update.prompt.md b/.github/prompts/plan-update.prompt.md
new file mode 100644
index 0000000..2154eb4
--- /dev/null
+++ b/.github/prompts/plan-update.prompt.md
@@ -0,0 +1,34 @@
+---
+mode: 'agent'
+description: 'Update action plan with new issue details, marks resolved questions and updates action plan steps as needed.'
+tools: ['codebase', 'search', 'searchResults', 'changes', 'findTestFiles', 'terminalSelection', 'terminalLastCommand', 'editFiles', 'fetch', 'runCommands']
+---
+
+<!-- Plan update document is a part of Onboard, Plan and Execute method applicable for software engineering tasks using AI Agent. 
+
+* Its goal is to refine action plan document with answers to open questions, additional specifications, acceptance criteria, etc. You should always use this prompt to update the plan with relevant content.
+
+* Recommended models: Claude Sonnet 4+
+
+* How to use it: agent mode, choose one of the recommended models, launch prompt via `/plan-update <additional spec>`. Provide additional information as a parameter, i.e.: `/plan-update Answer to question 3 is...`
+
+-->
+
+You are an experienced software developer tasked with creating an action plan provided as ${file} to address an issue. Your plan is already generated and attached to this conversation, but you want to enhance it with additional information that was missing once plan was first created. Your goal is to produce a comprehensive, step-by-step plan that will guide the resolution of this issue.
+
+First, review the following information:
+
+<issue_update>
+
+${input:IssueUpdate}
+
+</issue_update>
+
+With information provided above, perform the following steps:
+
+1. Incorporate information provided as <issue_update> to the action plan; crosscheck the plan to see if it requires an update having in mind <issue_update> information.
+2. Check if any of the questions for others hasn't been answered by acceptance criteria and mark it accordingly if so.
+3. If any new questions for others arise from the <issue_update> information, add them to the list of questions for others.
+4. If at any point you see that relevant code parts section needs to be updated, update it accordingly.
+5. Check if root cause hypothesis needs to be updated and update it accordingly.
+6. If any next steps are no longer relevant, mark them as skipped and explain why.
diff --git a/README.md b/README.md
index 498289a..6f2f276 100644
--- a/README.md
+++ b/README.md
@@ -68,6 +68,10 @@ Located in `.github/prompts/`, these templates provide standardized approaches f
 - **`write-docs.prompt.md`**: Produces consistent documentation following repository standards
 - **`write-ears-spec.prompt.md`**: Creates requirements using Easy Approach to Requirements Syntax
 - **`copilot-setup-check.prompt.md`**: Evaluates and optimizes Copilot configuration
+- **`plan-onboard.prompt.md`**: Onboards new team members with project overview and resources
+- **`plan-create.prompt.md`**: Creates detailed project plans with milestones and stakeholders
+- **`plan-update.prompt.md`**: Updates existing plans with changes; shall be used for addressing open questions from the plan
+- **`plan-exec.prompt.md`**: Executes plans generated by `plan-create.prompt.md` step by step or by using multiple steps at once
 
 ### 3. Comprehensive Instruction System