Skip to content
Back to search

ai-unified-process-marketplace

MarketplaceGitHubIncomplete

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026. Its scripts were only partly scanned.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/AI-Unified-Process/marketplace with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/AI-Unified-Process/marketplace'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/ai-unified-process--marketplace/badge.svg)](/listings/ai-unified-process--marketplace)

HTML

<a href="/listings/ai-unified-process--marketplace"><img src="/api/listings/ai-unified-process--marketplace/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Before installing AI Unified Process, create `docs/vision.md` in the target project. It should describe the mission, target users, goals, scope, and constraints. A copy-ready [vision template](docs/templates/vision.md) is available.

Claude Code

/plugin marketplace add ai-unified-process/marketplace
/plugin install aiup-core
/plugin install aiup-flyway
/plugin install aiup-jooq
/plugin install aiup-spring-boot

This example is a REST API with Spring Boot and jOOQ; install the layer plugins of your project, or one combined stack plugin instead.

Any supported agent through Tessl

tessl init --agent agents
tessl install ai-unified-process/aiup-core
tessl install ai-unified-process/aiup-flyway
tessl install ai-unified-process/aiup-jooq
tessl install ai-unified-process/aiup-spring-boot

Tessl installs versioned skills and maps each plugin's MCP servers (its bundled `.mcp.json`) into the configured agent layout. Replace `agents` with a host-specific identifier such as `claude-code`, `cursor`, `gemini`, `codex`, `copilot`, or `copilot-vscode` when you do not want the vendor-neutral layout.

Create the first artifacts

Run the core skills in the target project:

/requirements
/entity-model
/use-case-diagram
/use-case-spec UC-001

Agents that do not expose skills as slash commands can invoke them by intent, for example: "Create the requirements catalog from `docs/vision.md`" or "Specify UC-001".

[Follow the complete getting-started guide →](docs/getting-started.md)

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 85 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. {
  2. "name": "ai-unified-process-marketplace",
  3. "owner": {
  4. "name": "Simon Martinelli",
  5. "email": "simon@martinelli.ch",
  6. "url": "https://unifiedprocess.ai"
  7. },
  8. "plugins": [
  9. {
  10. "name": "aiup-core",
  11. "source": "./aiup-core",
  12. "description": "AI Unified Process core - stack-agnostic requirements, entity model, and use cases, plus the construction orchestrators for layer plugins"
  13. },
  14. {
  15. "name": "aiup-vaadin-jooq",
  16. "source": "./aiup-vaadin-jooq",
  17. "description": "Deprecated — use the layer plugins. AI Unified Process for the Vaadin/jOOQ stack - migrations, implementation, tests"
  18. },
  19. {
  20. "name": "aiup-angular-jpa",
  21. "source": "./aiup-angular-jpa",
  22. "description": "Deprecated — use the layer plugins. AI Unified Process for the Angular/JPA stack - migrations, implementation, tests"
  23. },
  24. {
  25. "name": "aiup-blazor-dotnet",
  26. "source": "./aiup-blazor-dotnet",
  27. "description": "AI Unified Process for the C# / Blazor .NET 10 stack - migrations, implementation, tests"
  28. },
  29. {
  30. "name": "aiup-nestjs-nextjs",
  31. "source": "./aiup-nestjs-nextjs",
  32. "description": "Deprecated — use the layer plugins. AI Unified Process for the NestJS/Drizzle + Next.js stack - migrations, implementation, tests"
  33. },
  34. {
  35. "name": "aiup-flyway",
  36. "source": "./aiup-flyway",
  37. "description": "AI Unified Process migration layer - Flyway schema migrations from the entity model"
  38. },
  39. {
  40. "name": "aiup-jooq",
  41. "source": "./aiup-jooq",
  42. "description": "AI Unified Process persistence layer - jOOQ repositories, projections, and repository tests"
  43. },
  44. {
  45. "name": "aiup-jpa",
  46. "source": "./aiup-jpa",
  47. "description": "AI Unified Process persistence layer with Spring Data JPA - entities, repositories, and repository tests"
  48. },
  49. {
  50. "name": "aiup-spring-boot",
  51. "source": "./aiup-spring-boot",
  52. "description": "AI Unified Process Spring Boot layers - service, REST API, and external system client implementation and tests"
  53. },
  54. {
  55. "name": "aiup-vaadin",
  56. "source": "./aiup-vaadin",
  57. "description": "AI Unified Process UI layer with Vaadin - Flow and Hilla views, Browserless and Vitest view tests, and Playwright end-to-end tests"
  58. },
  59. {
  60. "name": "aiup-angular",
  61. "source": "./aiup-angular",
  62. "description": "AI Unified Process UI layer for Angular - standalone components, signals, HttpClient services, Vitest component tests"
  63. },
  64. {
  65. "name": "aiup-playwright",
  66. "source": "./aiup-playwright",
  67. "description": "AI Unified Process end-to-end layer - Playwright browser tests for use cases and test case journeys of any web UI"
  68. },
  69. {
  70. "name": "aiup-drizzle",
  71. "source": "./aiup-drizzle",
  72. "description": "AI Unified Process migration and persistence layers - Drizzle ORM schema, generated PostgreSQL migrations, repositories, and their tests"
  73. },
  74. {
  75. "name": "aiup-nestjs",
  76. "source": "./aiup-nestjs",
  77. "description": "AI Unified Process service and API layers - NestJS services, REST controllers, and their tests"
  78. },
  79. {
  80. "name": "aiup-nextjs",
  81. "source": "./aiup-nextjs",
  82. "description": "AI Unified Process UI layer - Next.js App Router pages on an API layer, and their component tests"
  83. }
  84. ]
  85. }
README.md · README · 310 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <!--
  2. Copyright 2025-2026 Simon Martinelli and the AI Unified Process contributors.
  3. Part of the AI Unified Process — https://unifiedprocess.ai
  4. Licensed under the Apache License, Version 2.0. See LICENSE and NOTICE.
  5. -->
  6. # AI Unified Process Marketplace
  7. AI Unified Process is a requirements-first workflow for taking software from a product vision to reviewed
  8. specifications, implementation, and traceable tests. This repository distributes the workflow as portable Agent
  9. Plugins and Agent Skills for Claude Code, OpenAI Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode, and other
  10. compatible coding agents.
  11. [Get started](docs/getting-started.md) · [Understand the workflow](docs/workflow.md) ·
  12. [Choose a plugin](#choose-your-plugins) · [Installation guides](#installation)
  13. ## Why AI Unified Process?
  14. AI-assisted development often jumps from a vague prompt directly to code. AI Unified Process inserts durable,
  15. human-reviewable artifacts between intent and implementation:
  16. - requirements with stable identifiers;
  17. - an explicit domain entity model;
  18. - use cases that define user goals and behavior;
  19. - test journeys that trace back to those use cases;
  20. - stack-specific implementation and tests built from the reviewed specifications;
  21. - a user guide, an acceptance protocol, and release notes derived from those same specifications.
  22. The workflow is inspired by the phases of the
  23. [Rational Unified Process](https://en.wikipedia.org/wiki/Rational_unified_process), adapted for coding agents and
  24. plain-text artifacts that live with the source code.
  25. ## Workflow
  26. ```text
  27. Inception Elaboration Construction Transition
  28. ───────────── ────────────────────────────────────────── ──────────────────────────────────────────── ──────────────────────
  29. /requirements → /entity-model → /stack → /use-case-diagram → /use-case-spec → implement → test → coverage → /acceptance-protocol
  30. ↘ /business-process /test-case → automate the journey /user-guide
  31. (optional) /release-notes
  32. /spec-review at any point, /next names the next step
  33. ```
  34. `aiup-core` owns the stack-independent path from vision to specifications. Construction continues either with
  35. layer plugins — one per technology, combined per project — or with one combined stack plugin (`aiup-blazor-dotnet`; the others are deprecated). With layer plugins, run
  36. `/stack` once; then *implement*, *test*, and *coverage* are `/use-case-implement`, `/use-case-test`, and
  37. `/use-case-coverage`, and *automate the journey* is `/test-case-implement`. A combined stack plugin uses its own
  38. `/implement`, test skills, and `/coverage-check` where it ships one.
  39. Transition hands the system over: `/acceptance-protocol` runs the user acceptance round from the test cases and sets
  40. the accepted use cases to `Done`, `/user-guide` writes the user guide from the use cases at `Tested` or `Done`, and
  41. `/release-notes` lists what reached `Done` since the last release.
  42. Each step reads the files produced by earlier steps. You can review or edit an artifact before continuing, and every
  43. later result remains traceable to the corresponding requirement or use case.
  44. [Read about phases, artifacts, traceability, and change handling →](docs/workflow.md)
  45. ### Automated construction
  46. The Werkstatt is a GitHub Actions workflow that builds the `Approved` use cases of a change branch through the same
  47. skills: specification lint, implementation, tests, build, coverage audit, and fix rounds. Its result is one pull
  48. request against the change branch, in which every finished use case has moved to `Tested`; a use case with a blocking
  49. open question stays `Approved` and keeps only its questions. The same stations also run on your own machine with
  50. `pipelines/werkstatt/run-local.sh`, in a worktree of their own and without a pull request.
  51. [Read how to set up and run the Werkstatt →](docs/werkstatt.md)
  52. ## Choose your plugins
  53. Install `aiup-core` in every project. For construction, combine **layer plugins** — one per technical layer — or add
  54. exactly one **combined stack plugin**. Do not mix both in one project. Of the combined stack plugins, only
  55. `aiup-blazor-dotnet` is maintained; the others are deprecated.
  56. ### Layer plugins
  57. Pick one plugin per layer the project has. `/stack` records the combination in the stack file,
  58. `docs/architecture/stack.md`; `/use-case-implement UC-001` runs the layer skills bottom-up, `/use-case-test UC-001` writes
  59. the tests from the integration layer up — from the entry layer the use case is offered through, the first layer whose
  60. tests run in process against the real database, so the layers below need no tests of their own
  61. (that API still gets its own contract tests when the use case is offered through it) — and `/use-case-coverage UC-001`
  62. audits the result. A use case offered through only some entry
  63. points (an administration screen without an API) says so in its `**Layers:**` line, and only those layers are built
  64. and tested. Optional `**Mockup:**` and `**API:**` lines link the screen designs the UI layer takes its layout from
  65. and the operations of an API contract agreed with a partner system, which the API layer builds as written.
  66. | Plugin | Layer | Skills |
  67. |-----------------------------------------|-----------------------|----------------------------------------------------------------------------------------------|
  68. | [`aiup-flyway`](aiup-flyway/) | Migration | `/flyway-schema` |
  69. | [`aiup-jooq`](aiup-jooq/) | Persistence | `/jooq-persistence`, `/jooq-persistence-test` |
  70. | [`aiup-jpa`](aiup-jpa/) | Persistence | `/jpa-persistence`, `/jpa-persistence-test` |
  71. | [`aiup-spring-boot`](aiup-spring-boot/) | Service, REST API, Client | `/spring-service`, `/spring-rest`, `/spring-client`, `/spring-service-test`, `/spring-rest-test`, `/spring-client-test` |
  72. | [`aiup-vaadin`](aiup-vaadin/) | UI (Flow, Hilla), E2E | `/vaadin-flow-ui`, `/hilla-ui`, `/vaadin-flow-ui-test`, `/hilla-ui-test`, `/vaadin-e2e-test` |
  73. | [`aiup-angular`](aiup-angular/) | UI | `/angular-ui`, `/angular-ui-test` |
  74. | [`aiup-playwright`](aiup-playwright/) | E2E (TypeScript) | `/playwright-e2e-test` |
  75. | [`aiup-drizzle`](aiup-drizzle/) | Migration, Persistence | `/drizzle-schema`, `/drizzle-persistence`, `/drizzle-persistence-test` |
  76. | [`aiup-nestjs`](aiup-nestjs/) | Service, REST API | `/nest-service`, `/nest-rest`, `/nest-service-test`, `/nest-rest-test` |
  77. | [`aiup-nextjs`](aiup-nextjs/) | UI | `/nextjs-ui`, `/nextjs-ui-test` |
  78. | Project | Plugins next to `aiup-core` |
  79. |-----------------------------|----------------------------------------------------------------------------------|
  80. | REST API, Spring Boot, jOOQ | `aiup-flyway`, `aiup-jooq`, `aiup-spring-boot` |
  81. | REST API, Spring Boot, JPA | `aiup-flyway`, `aiup-jpa`, `aiup-spring-boot` |
  82. | Vaadin Flow or Hilla, jOOQ | `aiup-flyway`, `aiup-jooq`, `aiup-spring-boot`, `aiup-vaadin` |
  83. | Vaadin Flow and a REST API | `aiup-flyway`, `aiup-jooq`, `aiup-spring-boot`, `aiup-vaadin` |
  84. | Angular, Spring Boot, JPA | `aiup-flyway`, `aiup-jpa`, `aiup-spring-boot`, `aiup-angular`, `aiup-playwright` |
  85. | REST API, NestJS, Drizzle | `aiup-drizzle`, `aiup-nestjs` |
  86. | Angular, NestJS, Drizzle | `aiup-drizzle`, `aiup-nestjs`, `aiup-angular`, `aiup-playwright` |
  87. | Next.js, NestJS, Drizzle | `aiup-drizzle`, `aiup-nestjs`, `aiup-nextjs`, `aiup-playwright` |
  88. | Next.js, Spring Boot, JPA | `aiup-flyway`, `aiup-jpa`, `aiup-spring-boot`, `aiup-nextjs`, `aiup-playwright` |
  89. ### Combined stack plugins
  90. | Plugin | Stack and responsibility | Construction skills |
  91. |---------------------------------------------|-----------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------|
  92. | [`aiup-vaadin-jooq`](aiup-vaadin-jooq/) | Vaadin Flow or Hilla with jOOQ (deprecated) | Flyway, implementation, Browserless or Karibu, Playwright, coverage check |
  93. | [`aiup-angular-jpa`](aiup-angular-jpa/) | Angular with Spring Boot and JPA (deprecated) | Flyway, implementation, Spring Boot tests, Vitest, Playwright, coverage check |
  94. | [`aiup-blazor-dotnet`](aiup-blazor-dotnet/) | C# and Blazor on .NET 10 with EF Core | EF migrations, Vertical Slices, bUnit, xUnit, Playwright |
  95. | [`aiup-nestjs-nextjs`](aiup-nestjs-nextjs/) | NestJS and Drizzle with Next.js (deprecated) | Drizzle migrations, implementation, Vitest, Supertest, React Testing Library, Playwright |
  96. The coverage audit belongs to `aiup-core`: `/use-case-coverage` and `/test-case-coverage` run the read-only
  97. [`uc-coverage-layered`](aiup-core/agents/uc-coverage-layered.md) sub-agent on demand. It reports which parts of the
  98. specification have no code or no test behind them, and which code has no specification behind it, and judges
  99. implementation and tests together, and with `html` saves the report as a page under `docs/coverage/`; `/use-case-test` and `/test-case-implement` end by handing off to it rather than
  100. running it themselves, so a construction round stays fast. Of the combined stack plugins, the deprecated
  101. `aiup-vaadin-jooq` and `aiup-angular-jpa` have their own `/coverage-check`; `aiup-blazor-dotnet` and the deprecated
  102. `aiup-nestjs-nextjs` have no audit.
  103. `aiup-vaadin-jooq`, `aiup-angular-jpa`, and `aiup-nestjs-nextjs` are deprecated in favour of the layer plugins and
  104. will be removed with `aiup-core` 4.0.0. The [migration guide](docs/migration.md) walks an existing project through the switch.
  105. `aiup-blazor-dotnet` stays a combined plugin: its Vertical Slice Architecture keeps a use case's handler and data
  106. access together in one slice, which horizontal layer plugins would split apart.
  107. `aiup-core` itself ships `/requirements`, `/entity-model`, `/use-case-diagram`, `/use-case-spec`, `/business-process`,
  108. `/test-case`, `/spec-review`, `/next`, `/open-questions`, `/architecture-decision`, `/reverse-engineer`, for the
  109. Transition phase `/user-guide`, `/acceptance-protocol`, and `/release-notes`, and, for layer plugins, `/stack`,
  110. `/use-case-implement`, `/use-case-test`, `/use-case-coverage`, `/test-case-implement`, and `/test-case-coverage`.
  111. Use only `aiup-core` when working with another implementation stack. The methodology ends at a documented boundary,
  112. so the specifications can feed a custom implementation workflow.
  113. ## Quick start
  114. Before installing AI Unified Process, create `docs/vision.md` in the target project. It should describe the mission, target users,
  115. goals, scope, and constraints. A copy-ready [vision template](docs/templates/vision.md) is available.
  116. ### Claude Code
  117. ```text
  118. /plugin marketplace add ai-unified-process/marketplace
  119. /plugin install aiup-core
  120. /plugin install aiup-flyway
  121. /plugin install aiup-jooq
  122. /plugin install aiup-spring-boot
  123. ```
  124. This example is a REST API with Spring Boot and jOOQ; install the layer plugins of your project, or one combined
  125. stack plugin instead.
  126. ### Any supported agent through Tessl
  127. ```sh
  128. tessl init --agent agents
  129. tessl install ai-unified-process/aiup-core
  130. tessl install ai-unified-process/aiup-flyway
  131. tessl install ai-unified-process/aiup-jooq
  132. tessl install ai-unified-process/aiup-spring-boot
  133. ```
  134. Tessl installs versioned skills and maps each plugin's MCP servers (its bundled `.mcp.json`) into the configured agent
  135. layout.
  136. Replace `agents` with a host-specific identifier such as `claude-code`, `cursor`, `gemini`, `codex`, `copilot`, or
  137. `copilot-vscode` when you do not want the vendor-neutral layout.
  138. ### Create the first artifacts
  139. Run the core skills in the target project:
  140. ```text
  141. /requirements
  142. /entity-model
  143. /use-case-diagram
  144. /use-case-spec UC-001
  145. ```
  146. Agents that do not expose skills as slash commands can invoke them by intent, for example: "Create the requirements
  147. catalog from `docs/vision.md`" or "Specify UC-001".
  148. [Follow the complete getting-started guide →](docs/getting-started.md)
  149. ## Generated artifacts
  150. The stack-independent workflow creates a shared documentation contract:
  151. ```text
  152. docs/
  153. ├── vision.md # maintained by the team
  154. ├── requirements.md # /requirements
  155. ├── glossary.md # /requirements (domain terms and synonyms to avoid)
  156. ├── entity_model.md # /entity-model
  157. ├── use_cases.puml # /use-case-diagram
  158. ├── processes/
  159. │ └── BP-001-*.bpmn # /business-process (optional), read by /test-case
  160. ├── use_cases/
  161. │ └── UC-001-*.md # /use-case-spec
  162. ├── test_cases/
  163. │ └── TC-001-*.md # /test-case
  164. ├── open_questions.md # /open-questions and the skills that find a gap (created with the first question)
  165. ├── user_guide/ # /user-guide: one chapter per actor, from the use cases at Tested or Done
  166. ├── acceptance/
  167. │ └── release-1.4.md # /acceptance-protocol: one protocol per acceptance round
  168. ├── release-notes.md # /release-notes: what reached Done, newest version first
  169. └── architecture/
  170. ├── stack.md # /stack (layer plugins only): layer → technology → skill → test skill
  171. └── decisions/
  172. └── ADR-001-*.md # /architecture-decision, each linked to the NFRs and constraints it serves
  173. ```
  174. Stack plugins consume these files and place generated code and tests according to the conventions of the target
  175. project. Their READMEs document the supported layouts and exact prerequisites.
  176. ## Existing applications
  177. Start an undocumented application with:
  178. ```text
  179. /reverse-engineer
  180. ```
  181. The skill inspects entry points, domain models, schema, authentication, and integrations, then proposes an entity
  182. model, use case diagram, and individual use case specifications. It reports behavior it cannot classify so the team
  183. can review gaps before adopting the result as a baseline.
  184. ## Installation
  185. - [Claude Code](docs/installation/claude-code.md) — add the marketplace and install plugins directly.
  186. - [Tessl](docs/installation/tessl.md) — install pinned plugins for one or more supported agents.
  187. - [Agent Plugins and manual setup](docs/installation/other-agents.md) — direct packages, skill locations, MCP examples,
  188. and host-specific caveats.
  189. Every plugin directory contains:
  190. - a Claude Code manifest and MCP configuration;
  191. - an Agent Plugins v1.0.0 `plugin.json` and `mcp.json`;
  192. - portable Agent Skills under `skills/`;
  193. - sub-agent definitions under `agents/`, where the plugin ships one;
  194. - a Tessl package manifest;
  195. - evaluation scenarios used during publication.
  196. CI keeps the three plugin manifest formats and their MCP definitions in sync, and verifies that every
  197. skill and document carries its copyright header and that each plugin ships `LICENSE` and `NOTICE`.
  198. ## Documentation
  199. | Guide | Contents |
  200. |--------------------------------------------------------------|----------------------------------------------------------------------------------------------|
  201. | [Getting started](docs/getting-started.md) | Select plugins, prepare a vision, install AI Unified Process, and create the first artifacts |
  202. | [Workflow and artifacts](docs/workflow.md) | Phases, traceability, artifact ownership, changes, and legacy projects |
  203. | [Migration guide](docs/migration.md) | Moving a project from a deprecated combined stack plugin to the layer plugins |
  204. | [Werkstatt](docs/werkstatt.md) | Building the approved use cases of a change branch in GitHub Actions or on your machine |
  205. | [Werkstatt architecture](docs/werkstatt-architecture.md) | The concept behind the Werkstatt: stations, gates, and the andon cord |
  206. | [Generation workflow versioning](docs/generate-workflow-versioning.md) | For maintainers: how the shared workflows are released behind the `v1` tag |
  207. | [Project setup](docs/guides/project-setup.md) | Recommended project documentation tree and agent guidance |
  208. | [Writing a layer skill](docs/guides/layer-skill.md) | The contract a team's own layer skill fulfils to run under `/use-case-implement` |
  209. | [Vision template](docs/templates/vision.md) | Starting point for `docs/vision.md` |
  210. | [CLAUDE.md template](docs/templates/CLAUDE.md) | Stack-neutral repository instructions for Claude Code |
  211. | [Complete tutorial](https://unifiedprocess.ai/tutorial.html) | Book Library example: stack-neutral analysis, then construction with the deprecated `aiup-vaadin-jooq`; use the layer plugins and the migration guide instead |
  212. Detailed skill behavior is documented in each plugin's `skills/*/SKILL.md`. Those files are the authoritative source
  213. for inputs, outputs, safety constraints, and execution steps; READMEs provide navigation and concise summaries.
  214. ## Repository layout
  215. ```text
  216. marketplace/
  217. ├── aiup-core/
  218. ├── aiup-vaadin-jooq/
  219. ├── aiup-angular-jpa/
  220. ├── aiup-blazor-dotnet/
  221. ├── aiup-nestjs-nextjs/
  222. ├── aiup-drizzle/
  223. ├── aiup-nestjs/
  224. ├── aiup-nextjs/
  225. ├── aiup-flyway/
  226. ├── aiup-jooq/
  227. ├── aiup-jpa/
  228. ├── aiup-spring-boot/
  229. ├── aiup-vaadin/
  230. ├── aiup-angular/
  231. ├── aiup-playwright/
  232. ├── docs/
  233. ├── pipelines/
  234. └── scripts/
  235. ```
  236. ## Learn more
  237. Visit [unifiedprocess.ai](https://unifiedprocess.ai) for the broader methodology.
  238. ## License
  239. Licensed under the [Apache License 2.0](LICENSE).
  240. ## Copyright and trademark
  241. Copyright 2025-2026 Simon Martinelli and the AI Unified Process contributors. The skills and documentation
  242. are licensed under Apache 2.0. "AI Unified Process" identifies the original methodology by Simon Martinelli
  243. ([unifiedprocess.ai](https://unifiedprocess.ai)). You may fork and modify this work under the license terms,
  244. but derived works must keep the [NOTICE](NOTICE) file and may not present themselves as the official
  245. AI Unified Process. If you build on it, please say so and link to this repository.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.