WYSIWID Principles

Enforce declarative synchronization and provenance in software architectures with YAML rules.

Updated Aug 23, 2026
One-click install
npx skills add https://github.com/mkolb22/zen-plugin --skill wysiwid-principles
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: WYSIWID Principles
Source: https://github.com/mkolb22/zen-plugin/tree/main/skills/wysiwid-principles
Command: npx skills add https://github.com/mkolb22/zen-plugin --skill wysiwid-principles

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

WYSIWID Principles enable legible software systems by enforcing a declarative, rule-based orchestration that makes behavior observable and auditable.

Core Features & Use Cases

  • Concepts: define independent stateful components with clear boundaries.
  • Synchronizations: write YAML rules that describe WHEN and HOW components interact, ensuring predictable workflows.
  • Provenance: maintain a complete audit trail of actions and triggers for debugging and cost analysis.

Quick Start

Describe a practical example that applies WYSIWID to a feature development workflow, mapping story → architecture → implementation with clear provenance.

Frequently Asked Questions about WYSIWID Principles

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

FAQPage Schema
How do I make tightly coupled software architecture more legible and auditable?

You can make tightly coupled software architecture legible by enforcing declarative synchronization rules and provenance, which establishes clear component boundaries and maintains a complete audit trail of interactions.

What is the best way to track provenance across software development workflows?

Tracking provenance across software workflows requires formalizing component interactions with explicit rules, ensuring a complete audit trail of triggers and actions is maintained for debugging and cost analysis.

How do I use declarative rules to synchronize stateful components in production codebases?

You can synchronize stateful components in production codebases by writing declarative YAML rules that explicitly define when and how independent concepts interact, ensuring predictable workflows.

Can I apply declarative architecture principles to feature design and education?

Yes, you can apply declarative architecture principles to feature design and education by reasoning about concept interactions across requirements, architecture, implementation, quality, and version workflows.

Why does unclear software architecture make debugging and cost analysis difficult?

Unclear software architecture lacks explicit provenance and observable behavior, making debugging difficult because interactions between tightly coupled components are not formally tracked or audited.

Does this approach require specific dependencies to manage concept interactions?

No specific dependencies are required to manage concept interactions, as the approach relies on defining independent stateful components and declarative synchronization rules within your existing architecture.