Skip to content
Back to search

arc-studio

SkillWorks with CodexGitHub

Mechanical plan/dev/self-audit/external-audit gates for AI coding agents, with a configurable role-routing topology engine, an MCP-UI live status panel, and native-tooling Claude Code V2 dispatch. Claude Code, Codex, OpenClaw, and PyPI.

Safety scan

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

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/arch1esun-arcgentic/badge.svg)](/listings/arch1esun-arcgentic)

HTML

<a href="/listings/arch1esun-arcgentic"><img src="/api/listings/arch1esun-arcgentic/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.

Codex local install

git clone https://github.com/Arch1eSUN/Arcgentic.git arcgentic
cd arcgentic
bash scripts/install-codex-local.sh --plugin-root .

Then start in a saved project workspace and ask:

Use Arcgentic to build this idea: <your idea>

npm bundle install

Use this if you want the Arcgentic plugin assets through npm:

npm install -g arcgentic
arcgentic install-codex-local

The npm package is a zero-dependency plugin bundle and Codex local install helper. It includes the skills, agents, scripts, schemas, templates, and platform manifests. The Python CLI is still published separately on PyPI.

Claude Code install

/plugin marketplace add Arch1eSUN/Arcgentic
/plugin install arcgentic@arc-studio

Then start inside your project:

Use Arcgentic to build this idea: <your idea>

For Claude Code V2 experimental workflow setup:

If your Claude Code session's own tool list already includes `Agent`, `SendMessage`, and `ListAgents` (native tooling / "tier 0"), no setup step is needed — the session broker uses those tools directly and this is the preferred, dogfood-verified path (see "Platform status" above). Only run `install-hooks` below as a fallback, for sessions that lack those three tools:

arcgentic claude-code-broker install-hooks \
  --settings .claude/settings.local.json \
  --state .agentic-rounds/state.yaml

CLI install

Use this if you only need the command-line helper:

pipx install arcgentic
arcgentic --help

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 · 34 lines

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

  1. {
  2. "name": "arc-studio",
  3. "owner": {
  4. "name": "Arc Studio"
  5. },
  6. "metadata": {
  7. "description": "Arc Studio Claude Code plugins."
  8. },
  9. "plugins": [
  10. {
  11. "name": "arcgentic",
  12. "source": {
  13. "source": "github",
  14. "repo": "Arch1eSUN/Arcgentic"
  15. },
  16. "description": "Moirai-derived gated engineering workflow for AI coding with V2 fixed-role orchestration.",
  17. "version": "2.2.1",
  18. "author": {
  19. "name": "Arc Studio"
  20. },
  21. "homepage": "https://github.com/Arch1eSUN/Arcgentic",
  22. "repository": "https://github.com/Arch1eSUN/Arcgentic",
  23. "license": "MIT",
  24. "keywords": [
  25. "agentic-harness",
  26. "round-driven-development",
  27. "external-audit",
  28. "reference-first",
  29. "lesson-codification"
  30. ],
  31. "category": "productivity"
  32. }
  33. ]
  34. }
README.md · README · 537 lines

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

  1. # Arcgentic
  2. <p align="center">
  3. <img src="./assets/arcgentic-logo.png" alt="Arcgentic logo" width="168">
  4. </p>
  5. > **Arcgentic is a harness engineering layer for AI coding agents. It turns
  6. > ad-hoc prompting into a gated engineering workflow.**
  7. **中文文档 -> [README.zh-CN.md](./README.zh-CN.md)**
  8. [![status](https://img.shields.io/badge/status-stable-brightgreen.svg)](#status)
  9. [![license](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
  10. [![version](https://img.shields.io/badge/version-v2.2.1-blueviolet.svg)](#status)
  11. [![PyPI](https://img.shields.io/pypi/v/arcgentic.svg)](https://pypi.org/project/arcgentic/)
  12. [![npm](https://img.shields.io/npm/v/arcgentic.svg)](https://www.npmjs.com/package/arcgentic)
  13. [![MCPVault](https://mcpvault.io/badge/arcgentic.svg)](https://mcpvault.io/servers/arcgentic/health?utm_source=external_badge&utm_medium=referral&utm_campaign=mcp_health_report)
  14. Arcgentic helps Codex and Claude Code run software work as a disciplined
  15. sequence: clarify the idea, plan the work, build it, self-audit it, optionally
  16. run a realistic user test, audit it independently, then close only when the
  17. evidence is good enough.
  18. It is for people who already use AI coding tools, but do not want every session
  19. to depend on memory, vibes, or a lucky prompt.
  20. ## Where it came from
  21. Arcgentic started as the development discipline behind
  22. [Moirai](https://github.com/Arch1eSUN/Moirai), a real agent project where AI
  23. coding had to survive 30+ strict development rounds, repeated `NEEDS_FIX`
  24. audits, planned handoffs, role boundaries, self-audit, external audit, and
  25. recoverable session state.
  26. This plugin packages the patterns that survived that work so Codex and Claude
  27. Code users can apply them to their own complex projects. It is not a new coding
  28. agent, and it does not copy Moirai-specific phase numbers, fact shapes, or
  29. runtime internals. It is the workflow layer extracted from real agent
  30. development.
  31. ## Harness engineering
  32. Arcgentic sits in the harness layer around a coding agent.
  33. Codex and Claude Code are the agents. Arcgentic is the engineering harness that
  34. gives those agents roles, handoffs, stop states, audit gates, and evidence.
  35. This is the same direction people describe as moving from vibe coding toward
  36. agentic engineering: the important work is not only prompting the model, but
  37. building the workflow around the model so its output can be checked, routed,
  38. and trusted.
  39. Related reading:
  40. - [Martin Fowler / Thoughtworks: Harness engineering for coding agent users](https://martinfowler.com/articles/exploring-gen-ai/harness-engineering.html)
  41. - Andrej Karpathy's broader "vibe coding -> agentic engineering" framing
  42. ## 30-second version
  43. | Question | Answer |
  44. |---|---|
  45. | What is it? | A harness engineering layer for Codex / Claude Code: roles, handoffs, audits, stop states, and pass/fix gates around the coding agent. |
  46. | What problem does it solve? | AI coding sessions drift: scope changes silently, context gets lost, tests are skipped, and "done" often means "the assistant said it is done." |
  47. | Who should use it? | Heavy Codex / Claude Code users, agent builders, AI-native teams, and people doing complex multi-round engineering work. |
  48. | What does it add? | A repeatable gated workflow with automated role dispatch: planning, dev self-audit, optional user testing, external audit, and closeout. |
  49. | What does it not do? | It does not replace your judgment, your tests, or your review process. It makes those steps harder to skip. |
  50. ## Platform status
  51. | Platform | V2 status | Verification |
  52. |---|---|---|
  53. | **Codex** | Complete V2 | Verified in a real Codex project workflow, including automatic Orchestrator thread setup and role-thread dispatch. |
  54. | **Claude Code** | Complete V2 | Verified in a real Claude Code session for `single-session-subagent` mode via a foreground `Agent` tier-0 broker dispatch — see `tests/dogfood/gate-3-claude-code-native-broker/RESULT.md`. That gate covered a single Planner role dispatch, not a full Planner→Developer→Auditor round loop. The `SendMessage`-based footer-correction retry path and `ListAgents` were not exercised by this gate (the footer was valid on the first attempt), and `multi-session-subthread` mode and the hook-backed fallback path remain unverified. |
  55. Codex is the best current experience. In the verified Codex path, the current
  56. project conversation becomes `Orchestrator`; Arcgentic then creates or reuses
  57. the role threads, names them, sends the right role prompt, waits for their
  58. return signal, and dispatches the next role without manual thread switching.
  59. Claude Code support now has dogfood evidence for `single-session-subagent`
  60. mode via a foreground `Agent` tier-0 broker dispatch, so treat that specific
  61. path as a verified real workflow. The `SendMessage`-based footer-correction
  62. retry path and `ListAgents` were not exercised by that gate, and
  63. `multi-session-subthread` mode and the hook-backed fallback path have not yet
  64. been verified in a real Claude Code session — all of these should still be
  65. treated as unproven.
  66. ## Distribution status
  67. | Channel | Status | Use it for |
  68. |---|---|---|
  69. | [GitHub Release](https://github.com/Arch1eSUN/Arcgentic/releases/tag/v2.2.1) | Published `v2.2.1` | Release notes, source archive, and verification context. |
  70. | [PyPI](https://pypi.org/project/arcgentic/) | Published `arcgentic==2.2.1` | Python CLI: gates, V2 state helpers, Claude Code broker, and audit tooling. |
  71. | [npm](https://www.npmjs.com/package/arcgentic) | Published `arcgentic@2.2.1` | Plugin asset bundle and Codex local install helper. |
  72. | Claude Code plugin marketplace | Manifest ready | Main Claude Code install path; `single-session-subagent` mode now has dogfood evidence via a foreground `Agent` tier-0 broker dispatch, but `multi-session-subthread` mode and the hook-backed fallback path remain unverified. |
  73. ## Install
  74. ### Codex local install
  75. ```bash
  76. git clone https://github.com/Arch1eSUN/Arcgentic.git arcgentic
  77. cd arcgentic
  78. bash scripts/install-codex-local.sh --plugin-root .
  79. ```
  80. Then start in a saved project workspace and ask:
  81. ```text
  82. Use Arcgentic to build this idea: <your idea>
  83. ```
  84. ### npm bundle install
  85. Use this if you want the Arcgentic plugin assets through npm:
  86. ```bash
  87. npm install -g arcgentic
  88. arcgentic install-codex-local
  89. ```
  90. The npm package is a zero-dependency plugin bundle and Codex local install
  91. helper. It includes the skills, agents, scripts, schemas, templates, and
  92. platform manifests. The Python CLI is still published separately on PyPI.
  93. ### Claude Code install
  94. ```text
  95. /plugin marketplace add Arch1eSUN/Arcgentic
  96. /plugin install arcgentic@arc-studio
  97. ```
  98. Then start inside your project:
  99. ```text
  100. Use Arcgentic to build this idea: <your idea>
  101. ```
  102. For Claude Code V2 experimental workflow setup:
  103. If your Claude Code session's own tool list already includes `Agent`,
  104. `SendMessage`, and `ListAgents` (native tooling / "tier 0"), no setup step
  105. is needed — the session broker uses those tools directly and this is the
  106. preferred, dogfood-verified path (see "Platform status" above). Only run
  107. `install-hooks` below as a fallback, for sessions that lack those three
  108. tools:
  109. ```bash
  110. arcgentic claude-code-broker install-hooks \
  111. --settings .claude/settings.local.json \
  112. --state .agentic-rounds/state.yaml
  113. ```
  114. ### CLI install
  115. Use this if you only need the command-line helper:
  116. ```bash
  117. pipx install arcgentic
  118. arcgentic --help
  119. ```
  120. ## Minimal example
  121. Without Arcgentic:
  122. ```text
  123. User: Build a small expense splitter.
  124. AI: writes code
  125. AI: says it is done
  126. User: later discovers missing edge cases, unclear scope, no audit trail
  127. ```
  128. With Arcgentic:
  129. ```text
  130. User idea
  131. -> current conversation becomes Orchestrator
  132. -> Orchestrator creates or reuses Planner and sends the planning prompt
  133. -> Planner returns the plan to Orchestrator
  134. -> Orchestrator creates or reuses Developer and sends the dev prompt
  135. -> Developer implements and returns a self-audit
  136. -> Orchestrator dispatches optional Test only if realistic use needs it
  137. -> Orchestrator creates or reuses Auditor and sends the audit prompt
  138. -> Auditor returns PASS / NEEDS_FIX / AUDIT_INCOMPLETE
  139. -> Orchestrator routes the next step
  140. ```
  141. The important difference is not that the AI writes more text. The important
  142. difference is that each role has a job, each stage has a stop condition, and
  143. "done" is not accepted until the workflow can explain why.
  144. ## Arcgentic recommends a mode first
  145. When you start Arcgentic with a new idea, the current session becomes
  146. `Orchestrator`. Before it plans or builds, it should judge whether the idea is a
  147. small fast project or a larger project that needs stronger review. Then it
  148. recommends one project-level mode and asks you to confirm or override it:
  149. | Mode | Choose it when | Tradeoff |
  150. |---|---|---|
  151. | **Single session, multiple agents** | You want the fastest run and a smaller demo surface. | Faster completion, weaker audit isolation. Planner, Developer, Test, and Auditor run inside the current Orchestrator session as fixed named role agents and are reused across rounds. |
  152. | **Multiple sessions, multiple threads** | You want stronger separation between planning, development, testing, and audit. | Slower completion, stronger audit discipline. Planner, Developer, Test, and Auditor use fixed project threads. |
  153. The choice is made once for the project. Arcgentic should not ask again every
  154. round unless you start a new project or intentionally reset the workflow.
  155. ## What changes in real use
  156. ### Before
  157. - One long AI coding session tries to remember everything.
  158. - The assistant mixes planning, coding, review, and closeout in one context.
  159. - Fixes are sometimes treated as audit work.
  160. - The next session has to reconstruct what happened.
  161. - "Pass" often means the assistant felt confident.
  162. ### After
  163. - The current session is the Orchestrator.
  164. - Planner, Developer, Test, and Auditor are separate roles.
  165. - Developer owns building, repairs, and self-audit.
  166. - Auditor owns stricter independent review.
  167. - Test is used only when realistic user behavior needs separate verification.
  168. - Closeout happens after the project/phase conditions are satisfied.
  169. ## The V2 workflow
  170. Arcgentic V2 follows this shape:
  171. ```text
  172. idea
  173. -> brainstorm and planning
  174. -> round handoff
  175. -> development
  176. -> developer self-audit
  177. -> optional user-test
  178. -> external audit
  179. -> pass or fix
  180. -> next round, next phase, or closeout
  181. ```
  182. The roles are fixed:
  183. | Role | Owns |
  184. |---|---|
  185. | **Orchestrator** | Routing, role dispatch, waiting, and deciding which role acts next. |
  186. | **Planner** | Brainstorming, project plan, phase/round structure, handoffs, and closeout decisions. |
  187. | **Developer** | Building, fixes, local verification, and self-audit. |
  188. | **Test** | Realistic user/session testing when the plan says it is needed. |
  189. | **Auditor** | Independent evidence review and PASS / NEEDS_FIX / AUDIT_INCOMPLETE decisions. |
  190. Arcgentic does not create a new role identity every round. The role names stay
  191. fixed: `Orchestrator`, `Planner`, `Developer`, `Test`, and `Auditor`.
  192. ## Custom role/state topology
  193. The role/state routing that decides "who acts next" is no longer a hardcoded
  194. table. It is a `Topology` (`toolkit/src/arcgentic/topology.py`) that a project
  195. can override via `project.arcgentic_v2.topology` in `state.yaml` — routes,
  196. which states each role may act from, and conditional next-role selection based
  197. on the returning role's `artifacts` (for example, routing differently depending
  198. on an audit outcome field). Zero-config projects get the exact same 5-role
  199. sequence as before, byte for byte; custom topologies are validated at parse
  200. time (unknown role keys and routes with no matching next state are rejected
  201. before they can leave a project stuck mid-round). This is for projects that
  202. need a different role graph than the default plan/dev/audit loop — most
  203. projects should never need to touch it.
  204. ## Codex V2
  205. Codex V2 is the verified path.
  206. In Codex, Arcgentic can run either V2 mode.
  207. The verified automation is:
  208. ```text
  209. User starts in a project conversation
  210. -> Arcgentic marks that conversation as Orchestrator
  211. -> Orchestrator asks for or records the project mode
  212. -> Orchestrator creates or reuses the fixed role thread/agent
  213. -> Orchestrator sends the role-specific prompt and artifact pointers
  214. -> the role finishes and actively returns to Orchestrator
  215. -> Orchestrator consumes the return and dispatches the next role
  216. ```
  217. The user should not have to manually create Planner, Developer, Test, or Auditor
  218. threads in the verified Codex flow.
  219. Single session, multiple agents:
  220. ```text
  221. Current project thread = Orchestrator
  222. -> Planner role agent
  223. -> Developer role agent
  224. -> optional Test role agent
  225. -> Auditor role agent
  226. -> Orchestrator continues
  227. ```
  228. Multiple sessions, multiple threads:
  229. ```text
  230. Current project thread = Orchestrator
  231. -> create/reuse Planner thread and send Planner prompt
  232. -> Planner returns to Orchestrator
  233. -> create/reuse Developer thread and send Developer prompt
  234. -> Developer returns to Orchestrator
  235. -> create/reuse optional Test thread only when needed
  236. -> create/reuse Auditor thread and send Auditor prompt
  237. -> Auditor returns to Orchestrator
  238. ```
  239. In multiple-thread mode, the Orchestrator should sleep after dispatching a
  240. role. It wakes only when the role returns its result. That prevents the
  241. Orchestrator from guessing when work is done or dispatching duplicate auditors.
  242. In single-session mode, the Orchestrator stays in the same thread and runs the
  243. named role agents directly. The role names still stay exact: Planner,
  244. Developer, Test, and Auditor. Later rounds reuse those same role identities.
  245. Use Codex V2 when you want the strongest current Arcgentic experience.
  246. ## Claude Code V2 experimental
  247. Claude Code V2 is complete as an experimental version. `single-session-subagent`
  248. mode now has real-session dogfood evidence via a foreground `Agent` tier-0
  249. broker dispatch (see `tests/dogfood/gate-3-claude-code-native-broker/RESULT.md`);
  250. `multi-session-subthread` mode and the hook-backed fallback path have not yet
  251. been verified in a real Claude Code session.
  252. The intended behavior is the same:
  253. ```text
  254. current session = Orchestrator
  255. -> create/reuse Planner session and send Planner prompt
  256. -> Planner returns
  257. -> create/reuse Developer session and send Developer prompt
  258. -> Developer returns
  259. -> optional Test only when needed
  260. -> create/reuse Auditor session and send Auditor prompt
  261. -> Auditor returns
  262. ```
  263. Claude Code experimental mode aims to reach the same no-manual-routing behavior
  264. through the session broker. That full automation has not yet been verified in a
  265. real Claude Code session. If automatic return does not work in your setup, use
  266. explicit copy-back: paste the role's return message into the Orchestrator so the
  267. workflow can continue.
  268. Use Claude Code V2 when you want to try the same discipline in Claude Code and
  269. are comfortable with experimental workflow behavior.
  270. ## MCP-UI status panel
  271. Arcgentic ships an optional MCP server exposing a live round-status panel via
  272. [MCP Apps](https://modelcontextprotocol.io/specification/draft/extensions/apps)
  273. (the January 2026 official MCP extension for rendering interactive UI inside a
  274. conversation). Install it with:
  275. ```bash
  276. pip install 'arcgentic[mcp]'
  277. ```
  278. and declare it in your project's `.mcp.json`:
  279. ```json
  280. {
  281. "mcpServers": {
  282. "arcgentic": {
  283. "command": "arcgentic",
  284. "args": ["mcp-serve"]
  285. }
  286. }
  287. }
  288. ```
  289. Calling the `round_status_panel` tool renders round id, per-role dispatch
  290. progress, and the latest audit verdict as an inline panel, with client-side
  291. auto-refresh (capped, pauses when the panel isn't visible) and a "dispatch
  292. next role" button that sends a chat message rather than mutating state
  293. directly — the panel has no write path of its own; the Orchestrator still
  294. drives every state change. On hosts without MCP Apps support (including plain
  295. terminal Codex/Claude Code sessions), the same tool call falls back to a plain
  296. text summary instead of failing.
  297. MCP Apps host support is still young — this feature is for MCP-UI-capable
  298. hosts (a graphical Claude/Codex client, not a bare terminal session).
  299. ## When to use Arcgentic
  300. Use Arcgentic for:
  301. - frequent Codex / Claude Code users who run real engineering work through AI;
  302. - agent builders who need clear role boundaries and handoffs;
  303. - small AI-native engineering teams;
  304. - complex repos, multi-round development, refactors, and agent products;
  305. - work where you need to prove AI-written code went through planning, testing,
  306. and audit before it was accepted;
  307. - sessions where you want future you to understand what happened.
  308. Arcgentic is intentionally heavier than normal prompting. If the task is not
  309. substantial, risky, or multi-step, the workflow can feel like using a full
  310. engineering gate for a tiny change.
  311. Do not use Arcgentic for:
  312. - a one-line command;
  313. - a tiny copy edit;
  314. - quick experiments where auditability does not matter;
  315. - small tasks where normal Codex or Claude Code prompting is enough;
  316. - exploratory questions with no development goal;
  317. - work where you do not care about auditability.
  318. ## What a good Arcgentic run produces
  319. A clean run should leave behind:
  320. - a readable plan;
  321. - a development result;
  322. - a developer self-audit;
  323. - a test report when the round needed realistic testing;
  324. - an external audit verdict;
  325. - a clear pass/fix/closeout decision.
  326. These artifacts matter because they make the workflow inspectable. You can come
  327. back later and see what was planned, what changed, what was checked, and why the
  328. round was allowed to close.
  329. ## Demo and examples
  330. Current evidence:
  331. - Codex V2 has been exercised in a real project workflow.
  332. - V2 completion evidence is recorded in the repository.
  333. - Simulated user workflow evidence is recorded in the repository.
  334. Planned adoption assets:
  335. - short Codex demo;
  336. - example project with before/after comparison;
  337. - Claude Code experimental run notes for `multi-session-subthread` mode and
  338. the hook-backed fallback path, after those are verified in a real session
  339. (`single-session-subagent` mode's run notes already exist at
  340. `tests/dogfood/gate-3-claude-code-native-broker/RESULT.md`).
  341. ## Troubleshooting
  342. ### It starts creating too many sessions
  343. Arcgentic V2 should reuse fixed role sessions. You should see only:
  344. ```text
  345. Orchestrator
  346. Planner
  347. Developer
  348. Test
  349. Auditor
  350. ```
  351. If you see `R1 Developer`, `R2 Auditor`, or similar names, that is not the
  352. intended V2 behavior.
  353. ### The Orchestrator keeps acting after dispatch
  354. The Orchestrator should stop after dispatching a role. It should resume only
  355. when the role returns information. If it keeps dispatching while a role is still
  356. working, the workflow is not following V2.
  357. ### Audit keeps looping
  358. Audit should not loop forever. Auditor decides `PASS`, `NEEDS_FIX`, or
  359. `AUDIT_INCOMPLETE`. If the evidence is missing and Developer can repair it, the
  360. workflow should go back to Developer. If the same audit gap cannot be resolved
  361. by another audit pass, it should stop instead of creating another auditor loop.
  362. ### Test runs every round
  363. Test is optional. Planner decides whether the current round needs realistic
  364. user/session testing. Many small rounds should go directly from
  365. Developer self-audit to Auditor.
  366. ## Status
  367. | Area | Status |
  368. |---|---|
  369. | Codex V2 | Complete and real-workflow verified. |
  370. | Claude Code V2 | Complete experimental version; `single-session-subagent` mode has real-session dogfood evidence via a foreground `Agent` tier-0 broker dispatch, `multi-session-subthread` mode and the hook-backed fallback path are still pending. |
  371. | Fixed roles | Complete. |
  372. | Optional Test role | Complete. |
  373. | Developer self-audit | Complete. |
  374. | External audit | Complete. |
  375. | Closed-project status no-op | Complete. |
  376. | README onboarding | Updated for adoption-first use. |
  377. | npm bundle | Published as `arcgentic@2.2.1`. |
  378. | Custom role/state topology | Complete. Zero-config behavior unchanged; custom topologies validated at parse time. |
  379. | MCP-UI status panel | Complete, optional (`pip install arcgentic[mcp]`). Depends on host MCP Apps support. |
  380. ## Roadmap
  381. Near-term:
  382. - verify Claude Code V2's `multi-session-subthread` mode, the
  383. `SendMessage`-based reuse-dispatch path, and the hook-backed fallback path
  384. in a real Claude Code session (`single-session-subagent` mode's
  385. first-dispatch/`create` path is verified; repeat dispatch via `SendMessage`
  386. is implemented but not yet dogfooded);
  387. - publish a small example project;
  388. - add a short demo walkthrough;
  389. - collect issue-template feedback from first users.
  390. Longer-term:
  391. - harden V2 across more project types;
  392. - improve example libraries for common workflows;
  393. - keep the README focused on adoption and first-run clarity.
  394. ## Feedback
  395. Open an issue if:
  396. - install failed;
  397. - the workflow was confusing;
  398. - a role did the wrong job;
  399. - your project did not fit the workflow;
  400. - Claude Code experimental mode behaved differently from the docs.
  401. Useful feedback includes:
  402. - which platform you used: Codex or Claude Code;
  403. - what you asked Arcgentic to build;
  404. - where the workflow got stuck;
  405. - whether the issue was planning, development, test, audit, or closeout.
  406. ## License
  407. [MIT](./LICENSE) - Copyright (c) 2026 Arc Studio

Ratings and comments

Sign in to rate this skill.

Sign in

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