An open method for turning ordinary-language product visions into safe, premium, autonomous AI-assisted software engineering workflows.
This repository is the public foundation for the Autonomous Product Engineering Method. It helps a person express an ambitious product idea in ordinary language, then guides AI agents, coding agents, autonomous workers, or human teams through product profiling, challenge, functional exploration, product cartography, foundation stabilization, parallel development, integration, supervised delivery, operation, and feedback-driven evolution.
The method is intentionally tool-agnostic. It can be adapted to Codex, Hermes, CLI agents, chatbots, custom multi-agent systems, or human teams using AI as a product engineering partner.
This is a documentation and prompt repository. It provides:
- a product-to-engineering method;
- reusable templates;
- copy-pasteable prompts;
- safety and quality gates;
- runbooks for autonomous workers;
- adapters for common agentic environments;
- a sanitized case study;
- self-audits and known risks.
This is not a magic automation claim. The method does not remove the need for judgment, testing, product taste, security review, or human approval for dangerous actions.
Users should not need to speak like product managers, software architects, UX researchers, or DevOps engineers.
They can say:
"I want a tool that builds apps for me."
or:
"The UI feels poor. I want something premium but still powerful."
The method forces the system to translate that language into:
- product intent;
- ambition level;
- user types;
- non-goals;
- risks;
- product layers;
- UX implications;
- architecture implications;
- capability maps;
- worker missions;
- tests;
- quality gates;
- cost boundaries;
- safe execution plans.
In this method, premium does not mean ornamental design, vague polish, or expensive models everywhere.
Premium means:
- immediate clarity;
- low cognitive load;
- reliable behavior;
- honest status;
- visible uncertainty;
- no hidden cost;
- strong defaults;
- deep configurability when needed;
- powerful but safe automation;
- testable journeys;
- user trust.
The target is the best of two worlds:
- Apple-like clarity, coherence, smoothness, and UX quality;
- Windows-like depth, configurability, control, and openness.
Avoid both extremes: beautiful but closed and limited, or powerful but cognitively heavy and messy.
Ordinary language
-> Product profiling
-> Clarification and challenge
-> Traceable project inference
-> Functional exploration
-> Product maps and contracts
-> Curation and falsification verticals
-> Versioned Foundation Freeze
-> Roadmap and build mission portfolio
-> Isolated development agents
-> Integration and independent gates
-> Supervised delivery and operation
-> Learning and foundation revision
The complete operating protocol is defined in Autonomous Vision-to-Product Method.
- Read Overview.
- Read Core Principles.
- Use the Product Brief Template.
- Run the Autonomous Product Architect prompt.
- Apply the Challenge Gate before building.
- For an ambitious end-to-end product, use the Vision-to-Product Control Pack and Vision-to-Product Orchestrator.
- Use Quality Gates before calling anything done.
- docs/: the method, principles, end-to-end Vision-to-Product protocol, gates, runtime model, risks, and limitations.
- templates/: reusable structured artifacts.
- prompts/: copy-pasteable prompts for agents and review flows.
- runbooks/: operational guides for common environments.
- adapters/: tool-specific adaptation notes.
- examples/: public-safe examples.
- case-studies/: sanitized lessons from Hermes Agency OS.
- audits/: self-critique, risk register, anti-patterns, and alternatives.
English is the canonical source. French is maintained as an official translation:
The method separates actions into three zones:
- Green: local, reversible, testable, low risk, no external side effect.
- Orange: structural, costly, impactful, or ambiguous; requires proposal before execution.
- Red: irreversible, destructive, public, financial, secret-related, production-changing, or externally messaging; requires explicit human approval.
No agent should publish, delete, spend money, expose services, send messages, change production, or handle secrets without explicit authorization and verifiable safeguards.
This repository is v0.2, an expanded public foundation. It now includes a complete Vision-to-Product operating protocol, but still requires field validation across diverse products, teams, and agent environments. It is not a final standard, certification, framework, or guarantee of safe autonomy.
MIT. See LICENSE.
MIT was chosen because this repository includes reusable templates, prompts, and operational snippets that people should be able to copy, adapt, and embed in their own workflows. A Creative Commons license can still be considered later if the project becomes primarily essay-style documentation.