01

An internal method—not a client-facing SaaS product

Loom is an evolving internal SOFTWAYS method and supporting platform. It is currently used to develop a governed approach to software-product delivery; it is not offered as a client-facing SaaS product and clients do not need to operate it.

The method exists because AI-assisted implementation increases engineering capacity while the lifecycle around that implementation often remains fragmented. Product intent, architecture, execution, tests, reviews and release decisions live in different tools and conversations. Loom connects their meaning without attempting to replace the specialist systems that produce them.

02

Three levels of product construction

The Loom Method separates reusable organisational governance, individual product definition and incremental product delivery. Each level has a different purpose and human authority.

  • Establish the Guild: define the reusable engineering operating boundary
  • Incept a Venture: define one product and its delivery foundation
  • Deliver Product Stories: release complete product increments one cohort at a time
03

What makes Loom different

Most delivery systems organise activity around projects, tickets or the output of individual tools. Product intent may live in documents, implementation in repositories, agent reasoning in temporary sessions, test evidence in CI and release judgement in conversations. The engineer is expected to connect that lifecycle mentally.

Loom treats the software-product lifecycle itself as an engineered and governed system. Guild authority, Venture intent, Product Stories, use cases, execution, evidence, findings, reviews and releases retain explicit relationships. The unit of progress is not agent activity or completed code; it is a reviewed product capability released as one coherent Story.

This creates a different boundary for AI. Agents can propose and execute within curated specifications, but cannot accept their own proposals, approve their evidence or redefine the product silently. Rejection becomes durable input to the next attempt, and accepted learning can be promoted into product knowledge. AI acceleration therefore operates inside human product authority rather than outside it.

04

Guild: define how products are delivered

A Guild establishes the shared foundation for its Ventures. It defines identity, ownership, roles, policies, engineering specifications, provider boundaries, evidence expectations and release governance.

The value is reuse with traceability. A new Venture can inherit accepted engineering standards while controlled exceptions remain explicit. Historical work retains the policy context under which it was executed and reviewed.

  • Engineering, security and documentation standards
  • Human review and separation-of-duty rules
  • AI provider and agent authority
  • Testing and evidence requirements
  • Environment, release, rollback and retention policy
05

Venture: define one product

A Venture represents one product and its lifecycle. Greenfield inception starts from a brief and develops the product vision, outcomes, initial Stories, use cases, architecture and delivery foundations.

Existing-system inception begins differently. It inspects repositories, documentation, schemas, delivery configuration and operational evidence to build a cited current-state baseline. Target outcomes and future Stories are proposed only after that baseline has been reviewed.

06

Story: release one coherent increment

A Product Story is the atomic release cohort. It owns the use cases and implementation changes required for one coherent product or system outcome.

The Story moves through discovery, design, implementation, validation and release as a complete unit. Partial implementation may exist during delivery, but partial release is not treated as Story completion.

07

Curated specifications guide execution

Agent execution is most useful when it begins with focused, accepted context. Loom gathers the Story objective, relevant product and architecture material, open findings, allowed scope, test requirements and human decisions into a bounded implementation context.

The agent can propose a plan or implementation. A human accepts, edits or rejects the proposal before material changes proceed. The platform preserves that boundary: Codex proposes; authorised people apply and approve.

08

Evidence, Review Gates and Findings

Execution activities and evidence are related but not identical. An activity records meaningful work. Evidence records an observed fact, such as a passing test profile or deployed artifact health. A Review Gate collects the requirements for a human decision.

Approval advances delivery. Rejection preserves the judgement and creates one or more Findings. A later attempt receives both the original objective and the exact unresolved finding, so the correction remains connected to the decision that required it.

09

Automated testing is part of the method

Testing requirements begin at Guild and Venture foundation, then become specific to each Story. Implementation evidence may include linting, type checks, unit, contract and integration tests. Release readiness adds deployment, end-to-end and health evidence.

Playwright provides bounded browser validation for critical journeys. Results can be related to Story behaviour and a particular candidate rather than stored as an unrelated CI report.

10

Controlled promotion to production

Local execution, staging validation and production delivery have distinct meaning. A local result cannot impersonate shared staging evidence. Staging validates an immutable candidate in an environment that exercises the required product journeys.

After a human production-readiness decision, the same approved artifact is promoted to production without rebuilding it. Deployment evidence, rollback inputs, production smoke tests and observation complete the Story's release history.

11

Integration rather than replacement

Loom does not need to become an IDE, source-control system, test runner, cloud console or observability platform. Codex performs bounded engineering work. Git and GitHub remain authoritative for source and collaboration. Playwright performs browser validation. Cloud and CI providers execute deployment workflows.

The internal method connects those systems around product intent and human decisions. The objective is not another tool for every task; it is a coherent product lifecycle across the tools already required.

12

What the method changes

The visible change is a delivery process in which intent, implementation and evidence remain traceable. The deeper change is cultural: speed is valuable, but only when the team can understand, review, support and improve what it releases.

That is the role of Loom inside SOFTWAYS delivery. It provides an evolving structure for AI-oriented engineering while keeping product authority and production responsibility human.