Pick the area
One product area with a real backlog and a real deadline.
xAct bridges the gap between generic and genius
The software
development process
for the age of AI coding.
Coding got cheap.
Being precise got expensive.
Your agents ship in minutes, and whatever you said is what you get, at speed. A line built on an assumption nobody wrote down costs the sprint that finds it and the sprint that unwinds it. The agents do the typing. Your people keep the judgment, and the record proves who decided what.
People collaborate01
A spec forms02
A prompt comes out03
All models via Amazon BedrockCustomer-managed KMS keysPasskey-first · enforced MFAAppend-only audit logSOC 2 Type II in progress
The cost of vague requirements
Ambiguity is the bill you are already paying.
Every one of these is a specification problem, not an engineering problem. It's paid quietly, out of engineering time, and nobody on the team is being sloppy.
6–10
Weeks from idea to a spec engineering will build from
30–40%
Of engineering effort spent redoing work built from unclear requirements
60%
Of architecture and security findings raised after the build, not before
0
Decisions in today's spec you can trace to a named owner. That's the one that hurts in an audit, in a handover, and on the day the person who decided leaves.
Illustrative ranges. Week one of a pilot replaces them with your own baseline.
Why it happensThe SDLC was built for
The SDLC was built for
humans handing work to humans.
Product, design, build, QA. Every arrow is a handoff, and every handoff re-explains context the step before it already had. Specs, tickets and meetings carry intent that lives in people's heads, not in the artifacts. That was affordable when the build took months. Now a coding agent finishes in minutes, then waits days for the next human to explain what was meant.
The bottleneck isn't your people. It's the stale process they're stuck inside.
Two years ago the hard part was building it, and intent sharpened while the code got written. That safety net is gone. The constraint moved off your engineers' hands and onto your team's ability to say exactly what it wants. That's a human question, so the answer is a process, not a better meeting.
Every stakeholder heardSpecificationTask planYour agent builds it
01Product
02Customer
03Architecture
04Design
05Engineering
06Security
07Operations
From concept to PRD to tasks.md
Two prompts front-load the thinking.
The thinking happens before a line of code is written. One prompt runs the dialogue that produces a PRD your people approve. The next turns that PRD into a task list an agent can build from.
Project concept
PRD development
- Guided dialogue
- Write · walk away · rewrite
Iterates for daysStakeholders weigh in and approve
PRD.md
Human-approvedPRD.md
Task list generator
- Analyze
- Decompose
- Map dependencies
- Add verification
tasks.md
- 1.1
- 1.2 · parallel
- 2.1 · needs 1.1
When the PRD calls for an agent, it runs on Amazon Bedrock AgentCore from day one.
Your first quarter
What changes for you in the first quarter.
Week two: a spec goes to engineering that nobody had to call a meeting about. Week six: the security finding that always lands after the build arrives before it. By the end of the quarter the product lead has stopped being the interface between everybody, because the spec does that job now, and the standing clarification meeting is off the calendar.
FASTER
Days, not weeks, to a build-ready spec
The questions run in parallel instead of one meeting at a time.
DURABLE
Alignment becomes an asset
Decisions live in the spec, not in someone's memory of the room. The team stops re-explaining the same context, and the spec arrives with the arguments already settled.
EARLIER
Rework stops arriving late
Architecture, security and operations specify before the build, not after.
PROVABLE
Auditors get evidence, not archaeology
Every requirement traces to the person who set it, with a timestamp.
Brownfield
Nobody is rewriting a twenty-year-old estate. So we start from it.
Every enterprise AI pilot dies on the same objection: your tool knows nothing about our environment. It's a fair objection. Nobody is on a green field, and legacy isn't the obstacle to the process. It's the foundation it builds on, so every spec is written against the estate you run.
01
The estate assembles itself
Upload a spec: OpenAPI, GraphQL SDL, database DDL or just an architecture doc. Import the inventory you already keep in LeanIX, ServiceNow or Okta. Sweep your GitHub organization. Scan your AWS account read-only. Deduplicated, with provenance on every entry and full history.
02
Honest, not confidently wrong
Anything we haven't seen in months is marked stale and kept in view. A confidently wrong map is worse than an honest partial one.
03
Live, not a snapshot
During the dialogue, specialists query your live systems through your own MCP servers, in-house or Atlassian, Notion, Airtable and Monday, so the answer that lands in the spec is the one your systems actually gave.
04
Integration stops being a phase
Describe an initiative in a paragraph and it proposes the parts of your estate it touches. Because the spec was written against your real systems, the agent speaks your protocols, honors your data boundaries, and authenticates against the identity provider you already run.
How it works
Precision doesn't survive a meeting. So we gave it a process.
Four people, an hour, the loudest voice wins, and no record of why. One dialogue replaces the handoffs between product management and engineering. You still make every decision. You make each one once, in one place, and it stays made.
STEP 01
People collaborate
Stakeholders settle the problem together, in dialogue, so context stops living in one head. More than 250 specialists across seven disciplines ask one question at a time, and each asks only what it still needs to know. Architecture, security and operations specify up front instead of reviewing later.
STEP 02
A spec forms
The dialogue resolves into a precise, reviewable spec: what the app does, what it connects to, and what it must never do. Every answer carries a name. Nothing is silently completed and nothing is left to memory. Change an early decision and the later ones that depended on it reopen.
STEP 03
A prompt comes out
The spec compiles into a prompt a coding agent executes without asking anyone what was meant: an ordered task plan and a seeded repository, handed to Claude Code, Cursor, Copilot or Codex. We don't make the agent smarter. We make the instruction right.
What gets built
What the prompt builds is not a prototype.
It isn't a demo you'll have to rebuild before it can go near a customer. It's an application your security team, your auditors and your integration owners all sign off.
01
Passes your security reviews
Enterprise controls built in, not bolted on. The obligations your security specialist raised are constraints inside the build instruction, so the agent can't build the insecure version.
02
Gives auditors exact evidence
Every requirement traces back to the spec that produced it and the person who set it. When a regulator asks why the system does that, the answer is a record, not a recollection.
03
Talks to the systems you already own
Your data stays where it lives. What gets built speaks the protocols of the estate it lands in and respects its boundaries from the first commit.
04
Serverless-first
Nothing to provision or patch. It absorbs your busiest hour and costs next to nothing at three in the morning, and operations specifies the cost controls in the same pass as the pipeline.
What gets built is what stays. No second project to make it real.
The alternatives
Every other route leaves you guessing at the spec.
More discovery, a better template, a consultancy, another product manager, more agent seats. The choice isn't us against a tool. It's whether the spec is settled before the build or argued about after it.
| Approach | Time to a build-ready spec | Decisions attributable | Output an enterprise can run |
|---|---|---|---|
| Do nothing | Weeks of meetings per release | No | Depends who was in the room |
| Coding assistants alone | Code in minutes, spec never written | No | Prototype-grade |
| Consultants and analysts | Weeks, then a document to interpret | Partly | Handed off, not owned |
| Build the process in-house | Months before it works | Maybe | Yours to maintain |
| xAct.ai | Days | Yes, person and timestamp | Serverless, security-reviewed |
Who it's for
Built where a vague requirement becomes a finding.
In most software, being wrong costs an afternoon. In a trading platform or a patient-facing product, it costs an exam finding, a breach notification, or a release you have to pull. That's where we start.
01
Financial services
A desk wants a new risk view by quarter-end. Security, model risk and the platform team each hold a veto, and each usually hears about it last. Here they specify it first, against PCI-DSS and SOC 2 controls, and every decision carries a name and a timestamp your examiners can read.
02
Digital health
A product team wants to ship a clinical feature fast. PHI handling, access control and audit are decided before a line is written, under HIPAA from the first question, and the clinician's workflow is in the room as its own voice rather than a persona slide.
Principles
Agentic means you have agency.
These principles are about people, not tooling. The constraint moved from writing code to saying precisely what you want, and it isn't moving back. All software will be built this way.
01
The baton passes one person at a time.
Every decision stays attributable to the person who made it. Six months from now, when someone asks why the integration behaves this way, there's a name, not a shrug and a search through Slack.
02
Code is disposable; intent is durable.
And so is the alignment behind it.
03
Review doesn't scale.
And neither does the meeting.
04
Slop is the new technical debt.
It comes from a vague prompt, and the undocumented meeting decision is where a lot of it is born.
Platform
What a regulated team needs that a prompt box doesn't have.
Every veto, in sequence
Product, customer, architecture, design, engineering, security and operations each speak from their own discipline, in order. Each inherits the full conversation before it, attributed, so nobody reopens what someone else already settled.
One model boundary: Amazon Bedrock
Every model call goes through Amazon Bedrock, by rule rather than by default: one API, one IAM boundary, one set of data-handling terms. Your dialogue is never used to train a model.
Your regime, not generic questions
The security specialist is configured for the regime you're actually under. A HIPAA, PCI-DSS, SOC 2 or GDPR project gets the right questions in the right order: compliance first, then authentication, then data protection.
An audit record that exports
Every question, answer and decision is attributed and timestamped in an append-only log, and the whole record exports as Markdown. The governance pack becomes a by-product of building the application, not a project after it.
Disagreement surfaced, not discovered
When the customer names EU data residency and the architect picked a single US region, the system says so out loud and routes the call to whoever owns it. It doesn't turn up in code review three months later.
Your agents read the spec directly
A public API on scoped keys, a developer portal, and xAct.ai as an MCP server. The process becomes a component in your pipeline, and your own agents read the specification without anyone copying and pasting it.
Decisions your organization keeps
Good answers become organizational positions. Reusable precedents, answer reuse across projects and search by meaning mean the next team starts from what the company already decided, instead of building its own version of it.
Pricing
What it costs, and what it pays back.
What you pay
- Priced per product area, not per seat, so the whole team can take part instead of the two people who happen to hold licenses.
- One spec, one fee. No discovery retainer, no change orders for questions.
- A pilot covers a single area, so the first number is small.
What it returns
- Rework avoided is the largest line. At current engineering cost, avoiding one quarter of it covers the fee.
- Every week cut from specification is a week of agent build capacity you already pay for.
- Late security and architecture findings stop landing after the build.
- Payback expected inside the first few specs.
We put your figures against this structure when we scope the pilot.
The pilot
One product area, two weeks, one spec.
The risk is two weeks of your own time on work you were going to do anyway.
Give it two weeks
We scope it, then stay out of the room.
Decide on the evidence
A spec in hand, every decision attributed, a build your engineers can start.
The success criterion, agreed before we start: a spec your engineers build from without calling a clarification meeting. If you don't get that, the pilot failed.
Pick the product area. We start there.
Two weeks from now you either have a spec your engineers will build from, or you have the meeting you were going to have anyway. Sign in to begin, or create an account.