Roadmap & What's Coming

[fredcallagan]

Arness is open source and actively developed. Here's what we're working on, what's on the horizon, and where we're headed longer term.

This isn't a fixed plan — it's a snapshot of our thinking. If something here matters to you (or something is missing), let us know in the comments or open an issue. Community input directly shapes what gets prioritized.

---

Now Exploring

These are actively being designed or implemented.

GitLab Support

Platform detection currently supports GitHub and Bitbucket. GitLab is a major gap — shipping, issue creation, PR review, and pick-issue all rely on platform integration. We're working on adding GitLab as a first-class platform across all three plugins.

Dependency Audit & Security Hardening

We've prioritised this due to the rapid evolution of model capabilities and the new risk surface that comes with it. As AI-assisted development tools become more powerful, the security and supply chain integrity of the projects they help build needs to keep pace.

Dependency audit — a new skill that runs npm audit / pip-audit / cargo audit, analyzes project dependencies for security vulnerabilities, outdated versions, and license compliance, assesses update risk using stored pattern knowledge, and routes updates through the appropriate ceremony tier.

Security & vulnerability assessment — expanding beyond the existing security specialist (Code) and security auditor (Infra) into a more continuous process: proactive vulnerability detection, dependency CVE monitoring, and security posture assessment as an ongoing workflow rather than a point-in-time check.

---

On the Horizon

These are planned but not yet in active development. They represent real gaps that users will encounter.

CI Validation for PRs

We're planning automated validation that runs on every pull request to the Arness repo: plugin.json schema compliance, marketplace.json version sync, skill and agent frontmatter validity, no hardcoded paths, and reference file existence checks. This is foundational for accepting community contributions with confidence.

Orchestration Plugin

A lightweight orchestration layer — a new plugin that sits above the three domain plugins and handles routing. Instead of needing to know whether to start with /arn-brainstorming, /arn-planning, or /arn-infra-wizard, a single entry point would detect your project state and route you to the right place. It would also check which plugins are installed and prompt you to install what's needed.

The three domain plugins stay focused on their jobs. The orchestration plugin handles the "where should I go?" question.

Cross-Plugin Transition Polish

The Spark → Code and Code → Infra transitions are already well-integrated, but we want to improve the discoverability of what comes next at each boundary. The orchestration plugin will make transitions obvious, and we're reviewing the transition moments themselves to surface a brief summary of what carries forward when you move from one plugin to the next.

Changelog Generation

Arness already has all the raw material — feature specs, commit messages, PR descriptions, change records — but no skill to synthesize them into a structured CHANGELOG.md. We're planning a changelog generation skill for Code, and potentially extending it to Infra as well.

Plugin-Level Changelogs

When you upgrade from arn-code v3.0.0 to v3.2.0, you should know what changed. We're adding per-plugin changelogs so users can see new skills, behavior changes, and fixes between versions.

Accessibility Audit

Spark handles accessibility at design time (prototypes reference WCAG, the UX judge scores it). Code's specs include accessibility requirements. But there's no post-implementation audit that runs axe-core or similar tooling against the built application. We're adding this to close the gap between design intent and shipped reality.

Database Migration Support

Database migrations touch two plugins:

• Code — application-level schema migrations should be part of the development cycle. When a feature requires database changes, the plan should include migration files and the execution should generate them.
• Infra — rollback strategies for database changes during deployment. When a deploy goes wrong, the rollback procedure needs to account for schema changes, not just application code.

Skill Authoring Guide

We want community contributions to be straightforward. We're planning a contribution guide that follows Claude Code's best patterns for plugin development — covering skill structure, agent conventions, frontmatter, trigger descriptions, and the AskUserQuestion pattern. The goal is to make contributing a new skill as clear as possible.

---

Future Directions

Longer-term ideas we think are worth exploring. These are less defined and more open to community input.

Deeper Design Tool Integration

Spark already supports visual references comprehensively — the style-capture agent screenshots websites via Playwright and extracts design characteristics, Figma and Canva are integrated via MCP for importing design mockups, and a full visual grounding system (references, designs, brand assets) feeds into style exploration and prototype validation. What we're exploring longer term is deeper integration: tighter synchronization with live Figma files, design token import for automatic style-brief population, and component-level mapping between design tools and Spark's prototype builder.

Linear and Shortcut Issue Tracker Support

Issue tracking currently supports GitHub Issues and Jira. Linear and Shortcut are popular with the startup/small-team audience that tends to be early adopters of tools like Arness. Adding support would unlock feature extraction, issue picking, and assess pipeline integration for those teams.

Cross-Plugin Artifact Traceability

Every Arness artifact feeds the next stage, and all artifacts are stored in .arness/. But there's no single command that traces the full lineage of a feature — from product concept through stress test findings, to spec, plan, implementation report, and deployed PR. A traceability view that connects the dots across plugins would make the artifact chain visible, not just implicit.

Template Marketplace

The template system already supports versioning and update checks. Extending it to support community-contributed template packs — different report formats, documentation styles, or compliance-oriented templates — is a natural evolution.

Artifact Export for Stakeholders

Arness artifacts are designed for pipeline consumption (each feeds the next stage). A skill that exports the artifact chain as a self-contained document — for architecture reviews, compliance audits, or sharing with stakeholders who don't use Claude Code — would extend Arness's value beyond the developer's terminal.

---

What's NOT on the Roadmap (and Why)

A few things that came up in discussion but don't fit:

• Token/cost tracking — There are already good tools for monitoring Claude API usage. We'd rather recommend those than build a parallel system.
• Existing codebase onboarding — This already works. Run /arn-planning on any existing project and Arness auto-detects your stack, patterns, testing framework, and conventions. No separate setup step needed.
• Session recovery — Already built in. Entry points detect which artifacts exist on disk and offer to resume from where you left off.
• Monorepo support — Already supported. Infra has an explicit topology field, the codebase analyzer detects monorepo layouts, and all plugins preserve shared configuration.
• Spark → Code context loss — Not a gap. Code fully reads Spark's feature files, use cases, style-brief, and architecture-vision. The spec embeds all greenfield context and carries it through the entire pipeline. The Feature Tracker is updated on ship and automatically unblocks dependents.
• Cross-plugin handoff files — Infra's INFRA_HANDOFF files are correctly scoped as post-deployment artifacts consumed within the Infra plugin (deploy → verify → monitor). Code operates before deployment — there's nothing to hand off during development.
• Design tool integration — Spark already captures website screenshots via Playwright, integrates with Figma and Canva via MCP, and manages a visual grounding system with three asset categories (references, designs, brand) that feeds into style exploration and prototype validation.

---

Get Involved

The best way to influence this roadmap is to use Arness and tell us what's missing:

• Feature requests and bug reports — Issues
• Questions — Q&A Discussions
• Ideas — Ideas Discussions
• Contribute — CONTRIBUTING.md

If something on this list matters to you, comment below and tell us why. It helps us prioritize.

— Fryderyk / AppsVortex