MethodsThe new Method to build software.
Matters
2 of 2 criteria passed
- Open a matter. A matter records its client, type and fee basis
- Matter list. Matters filter by type and sort by next date
| Matter | Client | Stage | Next |
|---|---|---|---|
| Harlow Ltd | Discovery | 14 Nov | |
| A. Okafor | Inventory | 18 Nov | |
| Marlowe Foods | Due diligence | 21 Nov | |
| L. Reyes | Pleadings | 25 Nov | |
| Tanaka Studio | Drafting | 2 Dec |
Conflict check
2 of 2 criteria passed
- Client intake. A client is saved with every party they name
- Conflict check. Any match against an opposing party is flagged
Possible conflict: Brent Logistics, opposing party in Harlow v. Brent Logistics
Unbilled time
2 of 2 criteria passed
- Log billable time. Time is logged to a matter in six-minute units
- Unbilled summary. Unbilled hours total per matter, to the minute
42.5 h Total unbilled
Deadlines
2 of 2 criteria passed
- Court deadlines. Every deadline belongs to a matter and a date
- Upcoming list. The next deadlines show first, per matter
- 14 NovDisclosure lists due · Harlow v. Brent Logistics
- 18 NovEstate inventory filed · Okafor estate
- 21 NovDiligence report to client · Marlowe share purchase
- 25 NovDefence served · Reyes tenancy dispute
- 28 NovCase management hearing · Harlow v. Brent Logistics
- 2 DecLicence draft to counterparty · Tanaka licensing
The right method first
Your intent becomes an outcome, journeys and features, each with criteria a script can check.
Built, then broken
Agents build each feature. A different agent tries to prove it wrong.
Proven, then shipped
Only proven features merge, and they come together as the product.
Determine the right method. Engineer the better product.
Methods is AI software for product and engineering teams. You say what you want to achieve. Methods works out how much discovery, design, testing and review that change needs, writes pass or fail criteria for every feature, has AI agents build them, has a separate agent try to break each one, and merges only what passes. After release it checks whether the change did what it was for.
Methods is pre-alpha. It is being built now with a small group of design partners, and nothing is released yet.
- 01
The right amount of process
A typo fix and a change to how people log in should not get the same treatment. Methods sets the depth of discovery, review and testing from the risk of each change.
- 02
It builds, too
Coding agents and software factories take a ticket and write code. Methods decides what the ticket should be and how it must be proven, then runs the build with its own agents.
- 03
Done means proven
Every feature ships with evidence that each of its criteria is met, checked by scripts, not by the agent that wrote it. Then production shows whether the outcome happened.
Method: The Method is the unit of work
A Method is the plan for one piece of work: how much to find out first, which checks apply, and who or what does each step.
What you get.
Two programs that run on your own machines, with your own Git repository as the record. No hosted service and no account.
The engine
A background program that plans the work, hands each feature to an AI agent in its own copy of the code, runs the checks and merges what passes. It works with the model providers you choose.
The console
A web app on your machine where you set direction, watch every feature move from plan to proof, and answer the few decisions Methods will not make for you.
Your repository
Plans, criteria, results and evidence are saved as files next to your code, versioned in Git, so nothing lives only in our system.
Not installable yet. The open-source core is being built now, and design partners get it first.
See what is built so farCoding tools start at the ticket. Products start much earlier.
Give a coding tool “Build password reset” and it builds password reset. Whether that was the right change, how risky it is, what proof it needs and whether resets actually improved afterwards are left to you.
Methods starts earlier and finishes later. It works out the outcome, the plan and the proof first, then builds, checks the result in production and learns from it.
What Methods is not
- A coding assistant
- A collection of prompts
- A workflow engine
- A project-management tool
- A compliance system
- An SDLC checklist
- An orchestration layer over other agents
It borrows from all of these. What it adds is deciding which approach fits each change, then carrying it out.
From intent to outcome.
Methods covers the whole life of a change, not only the coding. At each stage it chooses how to work from the goal, the product, the architecture and the risk.
- 01
Understand
Intent, outcome, discovery and opportunity: what you are really trying to achieve, and whether the problem is understood.
- 02
Shape
Journeys and capabilities, solution, epics and features, elaborated until each has criteria a script can check.
- 03
Engineer
Architecture, build and test, by agents in isolated workspaces, one feature each.
- 04
Prove
Verify and release: a separate agent tries to break it, and nothing merges without evidence.
- 05
Observe
Production signals show whether the software did what it was for, not only that it deployed.
- 06
Learn
What worked and what failed changes the methods themselves for next time.
Seven questions, answered every time.
Methods reasons about every change in seven ways. Each one answers a question a good team asks before, during and after building.
- Product
- What is really being asked for, and what result would mean it worked? Finds the real intent, the outcome, the opportunities, journeys and capabilities, and the solution, epics and features.
- Method
- Which way of working fits this change? Decides which methodologies apply and which engineering strategy fits.
- Risk
- How careful do we need to be, and when must a person decide? Sets how much rigour, independence, evidence and human involvement the work needs.
- Production
- How is it designed, built, tested, secured and shipped? Architects, codes, tests, secures, integrates and deploys the product.
- Evidence
- Can we prove every requirement is met? Proves that requirements, claims and intended behaviour are actually met.
- Outcome
- Did users or the business actually get the result? Checks whether the software produced the intended user or business result, not just whether it deployed.
- Learning
- What should we do differently next time? Works out what worked and what failed, and how the methods should improve.
How Methods builds and proves it.
Six parts carry the build. Each has a page with what it does and what is not built yet.
- 01
Feature contracts
Before any code is written, each feature gets pass or fail criteria, the files it may touch and what it depends on.
- 02
Agents and workspaces
AI agents build one feature each in a separate copy of your code: a cheaper model for small changes, a stronger one for risky ones.
- 03
Verification
Scripts decide pass or fail, and a second agent whose only job is to break the feature tries to prove it wrong.
- 04
Verified merge
Nothing merges until its checks pass again against the latest version of your code.
- 05
The console
The app where you set direction and answer the decisions Methods will not make for you.
- 06
Cost meter
What each finished feature cost, and how often it passed first time.
What a finished feature carries.
Done means evidence, not a green tick from the agent that wrote the code. This is the record each feature is designed to carry, shown here with example data, so a person can check it before anything ships.
How verification worksEvidence record, demo data
Export invoices as CSV
rev a3f9c21
Criteria 4 of 4 met
- Exports every invoice in the selected range
- Amounts keep two decimals and the account's currency
- An empty range downloads a file with headers only
- Keyboard and screen reader can reach the export
Automated checks at a3f9c21
- Types and lintpassed
- Unit testspassed
- End to end, running apppassed
- Accessibilitypassed
Breaking agent
- 14 attempts by a separate agent
- 1 finding: a range across a month boundary dropped a day
- Fixed at the root cause, regression added, adjacent flows rerun
People and cost
- 1 decision handed to a person and answered
- Cost per feature, from the meter
Where Methods sits.
The approaches teams use today, from prompting a chatbot to running a factory of agents, and what each counts as done.
| Approach | Who drives | Unit of work | Done means |
|---|---|---|---|
| Vibe coding | A person prompts and accepts output | A prompt | It runs |
| Agentic coding | An agent; a person reviews each diff | A task | A person approved the diff |
| Software factories | A system runs the loop from ticket to pull request | A ticket | CI is green and a person approved |
| Methods | The control plane above: it chooses the method for each decision, then builds with its own agents underneath | An outcome, shaped into features with contracts | Every criterion proven, then the outcome observed in production |
Your code stays yours.
How Methods is designed to treat your code. It is not released yet; the security page lists what is built.
Local-first
The core runs on your machines against your repositories. Source is never proxied through Methods.
Any model
Claude, OpenAI, local models, deterministic workers and people are workers behind one interface.
State in your repository
The graph, contracts, runs and verifications are versioned with the code, in Git.
Open-source core
The core is Apache-2.0, meant to be useful without an account.
Measured per feature.
The numbers Methods will report for every feature. We publish the definitions now and the figures once real work has been measured.
- Cost per completed feature
- Model tokens spent on a feature from plan to merge, including failed attempts.
- First-pass rate
- Share of features that pass every automated check on their first build.
- Bugs found by the breaking agent
- Defects the separate agent found per feature, by kind, before anything merged.
- Decisions a person made
- How many choices Methods had to hand to a person per feature, and how long each one waited.
Build with us as a design partner.
Methods is pre-alpha. A small number of teams will run it on real work while it is built, and shape what it becomes.