design-twice

Generate divergent architectural proposals with contract-validated JSON and convergence detection.

Updated Mar 8, 2026
One-click install
npx skills add https://github.com/luyzkk/Anti-Vibe-Coding --skill design-twice
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: design-twice
Source: https://github.com/luyzkk/Anti-Vibe-Coding/tree/main/skills/design-twice
Command: npx skills add https://github.com/luyzkk/Anti-Vibe-Coding --skill design-twice

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve?

Prevents premature convergence on a single architecture by forcing multiple genuinely different proposal directions early, so the decision reflects your constraints instead of early assumptions.

Core Features & Use Cases

  • Parallel divergent architecture proposals: Generates 3 to 5 complete architectural directions using isolated sub-agents with distinct constraints per domain.
  • Constraint-first context extraction: Reads the codebase (stack, libs, patterns, relevant entities/schemas) to build shared constraints before proposing.
  • Structured comparison and recorded decision: Consolidates results into a comparison table, checks convergence, recommends a proposal, and registers the outcome in .claude/decisions.md with a DT- prefix.

Quick Start

Ask design-twice to explore an architecture direction by running /anti-vibe-coding:design-twice with your problem or feature description as the argument.

Frequently Asked Questions about design-twice

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I generate multiple architectural designs before committing to a software structure?

To generate divergent architectures, you can use a parallel sub-agent approach that extracts codebase constraints and produces 3 to 5 distinct proposals. This forces comparative evaluation before recording a final structural decision.

What is premature convergence in software architecture and how do I avoid it?

Premature convergence happens when a single architecture is chosen based on early assumptions. Avoid it by generating multiple genuinely different proposal directions early, ensuring your final decision reflects actual project constraints.

How do I record architectural tradeoffs and decisions in my codebase?

You can record architectural tradeoffs by consolidating parallel proposals into a comparison table and registering the selected outcome. This creates a documented decision log with a specific prefix for future reference.

Can I compare different data schema and frontend approach directions for a new feature?

Yes, you can compare different data schema and frontend approaches. The process applies constraint-first context extraction to generate complete, isolated architectural directions for both existing and greenfield codebases.

Does design-twice work with existing codebases or only greenfield projects?

It works with both existing and greenfield codebases. The process reads your current stack, libraries, patterns, and relevant entities to build shared constraints before generating isolated architectural proposals.

When should I not use parallel divergent architecture proposals?

You should avoid generating parallel divergent architecture proposals for simple, deterministic changes that lack structural tradeoffs. The approach is designed for complex decisions involving technology choices, data schemas, or system structure.