Specification-first development made practicalSee how
ArtDeco

Your artless development co|

ArtlessDev is about removing unnecessary ceremony from software development. ArtDeco, our specification-first system, makes requirements your single source of truth—whether extracted from code, converted from documents, or authored fresh. Evidence-backed, human-verified, AI-assisted.

How it works

Structure Knowledge

Scenarios, rules, contracts, vocabulary with linking

Bootstrap Spec

Extract from code, convert docs, create interactively, or author manually

Maintain & Evolve

Direct editing for precision or natural text for holistic refinement

Consume

Access specs via MCP & RAG for code generation, tests, Q&A, and more

Explore full lifecycle →
Foundation

Specification-driven development, made accessible

Specifications are the authoritative source of truth that drives development, testing, and collaboration—not documentation that follows after the fact. ArtDeco makes this practical for teams at any starting point.
Specification-driven development inverts the traditional software lifecycle. Instead of writing code first and documenting afterward—a practice that guarantees documentation will fall behind—you start with clear, verifiable specifications. Implementation derives from specifications, not the other way around. This approach makes intent explicit, enables verification, and ensures every decision traces back to a requirement.
SDD principles work best when specifications come from anywhere and everyone can participate. Extract from existing code and documents. Enable non-technical stakeholders to shape requirements. Make spec-driven development practical for teams at any starting point—not just greenfield projects with technical authors.
Learn more about Spec-Driven Development principles and how they're being adopted across the industry.

Specification-first at the core

Scenarios, rules, contracts, and vocabulary stay authoritative. Code and docs serve the spec, not the other way around.

Evidence and provenance

Every claim traces back to source: code, documents, or conversations. Traceability is built in for audits and trust.

Human-in-the-loop by design

AI handles mechanical extraction and synthesis; people decide what matters and when it's ready.
How it works

A complete lifecycle for specifications

Built on atomic units of knowledge—from creation through evolution to consumption.

Organize: what are claims?

Scenarios

Testable GIVEN-WHEN-THEN behavior—the primary unit of specification

Rules

Constraints with modal operators (must, may, should)

Contracts

Data models, APIs, schemas with field:type patterns

Vocabulary

Definitions ("A User is...", "Customer has...")

Each claim is structured, versioned, evidence-linked, and immutable. They form the single source of truth; everything else—documents, code, tests—derives from them.

Operate: bootstrap → maintain → consume

Bootstrap Spec

Get from zero to initial specification. Meet knowledge where it lives:

  • •Extract from code: Reverse-engineer legacy systems into structured specs
  • •Convert documents: Turn RFCs, PRDs, wikis into verifiable claims
  • •Create interactively: Guided conversations with domain experts
  • •Author manually: Direct creation for critical requirements

All paths produce the same deterministic output with full provenance

Maintain & Evolve

Keep specs living and evolving. Two complementary modes for different thinking styles:

  • •Direct editing: Precision control of individual claims one at a time
  • •Natural text editing: Compose claims into readable documents, refine holistically, then break back into precise updates

Claims remain authoritative; documents are transient editing surfaces

Consume

Specifications come alive through consumption. Access your specs via MCP and RAG interfaces—stable, structured feeds for any downstream use. Build whatever you envision:

  • •Code generation: Translate specs into implementations
  • •Test templates: Generate acceptance tests from scenarios
  • •Q&A: Answer questions about your system from authoritative specs
  • •Multi-agent workflows: Coordinate multiple AI agents with shared specs
  • •and whatever you imagine

Stable spec format enables reliable, multi-agent compatible downstream value

Standing on shoulders

Practical remix of 60 years of proven thinking

ArtDeco is not original. We're a practical implementation of ideas that have been validated by decades of formal methods, test-driven development, behavior-driven development, and specification by example. AI simply makes extraction and maintenance feasible where manual effort made it prohibitive.

Rooted in proven ideas

We stand on formal methods, MDD, TDD, BDD, SBE, DDD, and living documentation. The principles are old and tested.

Why it resurfaces now

AI lowers the cost of creating, extracting, and maintaining specs. Natural language replaces specialized notation.

What is new with ArtDeco

A claim-based, evidence-rich spec repository that accepts any input mode and stays stable for downstream agents.
We inherit from Kent Beck (TDD), Dan North (BDD), Gojko Adzic (Specification by Example), Eric Evans (Domain-Driven Design), and many others who proved that intent matters more than implementation. Many teams and tools are exploring spec-driven approaches right now. We're all drawing from the same well of proven software engineering practices, exploring different paths to the same destination: making specifications the source of truth.
Why artless

Being artless in development

Artless means direct and honest. But it's also about literally "less art" in software projects. Less ceremony, less friction, less theater.

Remove unnecessary ceremony

Skip the frameworks that demand rituals. Build specifications in whatever form makes sense for your team and context.

Make implicit knowledge explicit

Most critical knowledge lives in code comments, tribal wisdom, and forgotten documents. Surface it systematically.

Trust evidence over process

Every requirement traces to actual sources. No hand-waving, no "trust me"—just verifiable claims with receipts.
Join the community

Build from specifications, not assumptions

Start with what you have: extract from code, convert documents, or author fresh requirements. Every claim stays tied to evidence, ready for tests, AI agents, and audits.
Join the preview →