Universal Project Intelligence & Build Orchestrator — a planning, architecture, and orchestration skill that turns raw human requests into systems that can be understood, reviewed, built, tested, verified, and maintained.
Version: 2.0.0 · Status: Stable / Living Skill
Most requests an agent receives are not clean specifications. They are ideas, problems, half-finished thoughts, screenshots, existing repositories, or single sentences like "buat website jualan".
This skill exists to close that gap. It takes whatever the user gives and runs it through a disciplined pipeline:
raw intent → problem understanding → recommended solution → specification
→ architecture → implementation plan → approval → build → verification
→ maintenance
The goal is not to generate as much code as possible. The goal is to find the most appropriate solution for the user's objective with the lowest justified complexity, the highest achievable quality, and an architecture strong enough to grow realistically.
- Universal request interpretation — handles clear, vague, ambiguous, partial, scattered, changing, and assumption-laden requests, as well as existing projects, ideas, problems, screenshots, repositories, code, workflows, and product asks.
- Canonical project model — every request is normalized internally into: objective, problem, users, environment, inputs, processes, outputs, constraints, dependencies, risks, success criteria, scope, unknowns, assumptions, decisions.
- Adaptive planning depth — SIMPLE / MEDIUM / COMPLEX / PRODUCTION-CRITICAL classification determines how deep planning goes. Simple requests get compressed plans; complex ones get full blueprints.
- Requirement engineering — explicit, implied, operational, quality, and future requirements; P0–P3 prioritization; hidden-requirement discovery; full traceability from requirement down to test case.
- Solution exploration — simple / recommended / advanced options compared on complexity, cost, speed, flexibility, maintenance, scalability, and risk; build / buy / connect analysis per capability.
- Scope control — in-scope / out-of-scope / future-scope, MVP engine (Must / Should / Could / Future), scope protection against unbounded growth.
- Architecture — domain discovery and boundaries, data modeling from domain + behavior (not pages → tables), API architecture, source-of-truth decisions, concurrency, storage, background jobs, caching, search, notifications.
- Change impact analysis — any post-baseline change is analyzed across every layer and classified LOW / MEDIUM / HIGH / BREAKING, then propagated systematically through all affected artifacts.
- Dependency graph & critical path — work is modeled with dependencies, blockers, critical path, and parallelizable branches.
- Conflict detection & resolution — requirements, features, permissions, architecture, UX, performance, security, budget, and timeline conflicts are surfaced before implementation, with a defined resolution priority.
- Reverse planning & reverse impact — verifies from desired outcome backwards, and propagates implementation discoveries back into the specification.
- Plan-vs-actual verification — compares the approved specification against the built project: missing features, unintended extras, behavior changes, architecture drift, undocumented dependencies, test gaps.
- Architecture drift detection — classifies drift as intentional improvement, necessary adaptation, scope change, or accidental drift (which must be fixed).
- Security planning — authentication vs authorization, permission matrices, threat modeling, privacy, abuse cases, no-frontend-trust rule, dangerous-action controls, human-in-the-loop for high-risk automation.
- Testing strategy — risk-based unit / integration / E2E / visual / security / performance selection, negative testing, test traceability, definition of done.
- Deployment & operations — environments, secrets, migrations, rollback, backup/recovery, observability, reliability, cost and scale planning.
- Specialist orchestration — discovers and delegates to specialist skills instead of duplicating their knowledge, and merges their outputs with consistency integration.
- Self-critique & adversarial review — pre-approval quality gates from product, UX, architecture, security, QA, and operations perspectives, followed by a simplification pass.
- Maintenance & evolution — maintenance mode with the same impact analysis system, technical debt register, documentation drift detection, post-project learning, and project memory.
The skill is an orchestrator, not a monolith:
User Request
↓
universal-project-intelligence (understand / scope / architecture / UX reqs)
↓
specialist skills (design, database, security, testing, ...)
↓
Implementation
↓
Testing / QA / Verification
The universal skill owns: intent extraction, requirement engineering, scope, architecture decisions, dependency planning, impact analysis, and verification. Specialist skills own their domains (e.g. visual design language belongs to the design skill). The universal skill never duplicates specialist knowledge when a specialist is available — it references and delegates.
Default behavior for any project request:
Understand → Plan → Review → Approval → Build → Verify
- Intent analysis — extract objective, problem, users, constraints, success criteria; separate the literal request from the actual goal.
- Requirement discovery — explicit + implied + hidden requirements, prioritized P0–P3, with an assumption ledger (confirmed / assumed / recommended / unknown / decision-required).
- Scope & MVP — in/out/future scope, Must/Should/Could/Future.
- Architecture — solution options, recommended choice, domain/data/API design, security, file structure.
- Specialist skills — auto-invoke relevant specialists (see below).
- Implementation plan — phases, dependency graph, critical path, parallel work, file-by-file specification for major files.
- Approval gate — blueprint presented for approval before major builds.
- Implementation — build following the plan, with continuous impact analysis for anything unexpected.
- Testing — risk-based strategy, negative tests, P0 coverage.
- Plan-vs-actual verification — specification compared against reality; drift classified and handled.
- Documentation — decisions, operational knowledge, and updated specs — not just code.
Approval exception: if the user explicitly says "langsung kerjakan" / "jangan tunggu approval" / "just build it", the skill completes internal planning and proceeds to implementation without an unnecessary approval gate — without skipping critical architecture/security reasoning.
This skill follows the standard agent skill layout. Place the folder in any discovered skills directory (highest priority first):
<project>/.zcode/skills/universal-project-intelligence/SKILL.md
<project>/.agents/skills/universal-project-intelligence/SKILL.md
~/.zcode/skills/universal-project-intelligence/SKILL.md
~/.agents/skills/universal-project-intelligence/SKILL.md
The folder must contain at minimum SKILL.md with valid YAML frontmatter
(name + description). The remaining files (README.md, CHANGELOG.md,
VERSION, examples/) support humans and maintenance; SKILL.md is what
the agent loads.
Verify installation by confirming the directory and SKILL.md exist at one
of the paths above and that the skill appears in the agent's available
skills list in a new session.
The skill is designed to trigger on natural project requests without being named. Examples that should activate it:
- "buat website portfolio"
- "buat marketplace"
- "buat aplikasi keuangan"
- "buat SaaS"
- "buat dashboard"
- "buat AI agent"
- "buat automation"
- "buat API"
- "perbaiki project saya"
- "redesign website ini"
- "tambahkan fitur X"
- "buat sistem untuk Y"
It also activates on existing-project contexts (a repository or codebase is provided) and on raw ideas ("saya mau aplikasi untuk mengatur kerja").
Invoke explicitly by name when you want to guarantee it loads:
/skill universal-project-intelligence <your request>
or simply mention the skill name in your message.
Default for new or significant work. Produces a blueprint scaled to complexity:
- SIMPLE — objective, scope, recommended solution, architecture, implementation steps. Compressed, no bloat.
- MEDIUM — adds roles, user flows, data, API, states, tests, deployment.
- COMPLEX — adds domain architecture, permissions, lifecycle, integrations, security, observability, risks, trade-offs, dependency graph, traceability.
- PRODUCTION-CRITICAL — adds threat model, recovery, auditability, reliability, incident strategy, backup, rollback, compliance.
After approval (or after an explicit "just build it"), the skill drives implementation phase by phase following the dependency graph, applies change impact analysis to anything unexpected, and finishes with plan-vs-actual verification and evidence-based status reporting. It never claims completion without tool-verified evidence.
When a project already exists, the skill never assumes an empty slate and never jumps to redesign/rewrite. It runs:
Inspect → Inventory → Understand → Architecture Mapping → Dependency
Mapping → Risk Identification → Change Plan
and applies the minimal change principle: the smallest set of changes that solves the problem correctly. Rewrites only when the current architecture blocks the outcome, there is a security issue, debt is unsustainable, or migration was explicitly requested.
evolving-web-design is the recognized specialist for visual/interaction
design.
Rule: if the project has a UI, website, landing page, web app, SaaS UI,
dashboard, marketplace/e-commerce UI, portfolio, consumer application, or a
major redesign — and evolving-web-design is available in the environment —
the universal skill invokes it automatically. The user never needs to
say "use the design skill".
Division of labor:
- universal-project-intelligence provides: product, audience, positioning, pages, content hierarchy, primary CTA, user flows, brand context, UX priorities, responsive/performance/accessibility and technical constraints.
- evolving-web-design decides: visual direction, typography, color, composition, layout, interaction, motion, animation, visual grammar, anti-AI-slop strategy, responsive design.
Neither side overrides the other silently: design respects performance, accessibility, responsiveness, component reuse, and implementation reality; engineering preserves hierarchy, interaction, visual language, and motion intent. If specialist outputs conflict, resolution follows requirement → evidence → constraints → trade-off → recommendation, never "whoever spoke last".
See the examples/ directory for worked walkthroughs of
raw request → planning behavior → implementation readiness:
| File | Demonstrates |
|---|---|
examples/simple-request.md |
Simple request → compressed plan, no over-planning |
examples/web-project.md |
Web product → deep planning + automatic evolving-web-design handoff |
examples/existing-project.md |
Existing codebase → inspect-first, minimal change, impact analysis |
examples/ai-agent.md |
AI agent project → ambiguity handling, assumptions, AI safety architecture |
This skill uses Semantic Versioning
(MAJOR.MINOR.PATCH):
- MAJOR — fundamental architecture/scope changes to the skill itself
- MINOR — new capabilities added
- PATCH — clarifications and fixes
The current version is stored in VERSION and history in CHANGELOG.md.
Project specifications produced by the skill are also versioned the same
way, with an approved baseline locked after user approval and re-baselined
after major approved changes.
- Living blueprint: specifications produced by this skill are living documents. Implementation discoveries propagate back (reverse impact), plans update with justification + impact analysis, and documentation drift is fixed when found.
- Change control: significant changes to an approved baseline run through Inspect → Impact → Plan → Approve-if-needed → Implement → Verify.
- Post-project learning: after completion, capture what worked, what failed, technical debt, UX/design/architecture lessons, and reusable principles; store major decisions and rejected approaches if a memory system is available (never store unnecessary sensitive data).
At least once a year — or when the agent environment changes materially — review this skill for:
- Stale tool/skill references — does
evolving-web-design(or any referenced specialist) still exist under the same name? Update the integration section if it moved or was renamed. - Environment drift — do discovery paths, frontmatter requirements, or invocation mechanisms still match the current agent platform?
- Capability gaps — did real projects reveal missing guidance (new project types, new risk classes)? Add as MINOR versions.
- Bloat — did usage reveal sections that never pull their weight? Consolidate or remove as PATCH/MAJOR.
- Trigger quality — check whether the skill still triggers on natural requests and does not over-trigger on trivial questions.
- Not a substitute for domain expertise — for regulated domains (finance, health, legal), the skill escalates planning depth and flags compliance considerations, but professional/legal review remains the user's responsibility.
- No fabricated evidence — the skill refuses to claim builds, pushes, tests, or deployments succeeded without tool-verified evidence. If a capability is unavailable, it says so rather than simulating.
- Estimates are not promises — timeline output uses phases, dependency order, and complexity estimates; it deliberately avoids false time guarantees.
- Specialist-dependent quality — design/database/security output quality depends on the specialists actually available in the environment; without them, the skill falls back to its own general guidance and states that.
- Assumption risk — ambiguous requests are handled with stated reasonable assumptions. Materially wrong assumptions can still require re-planning; the assumption ledger exists precisely to make this visible.
- Context limits — very large existing codebases are inspected selectively (architecture, dependencies, conventions, risk areas), not exhaustively line-by-line.