Software architecture and UI/UX principles for building genuinely new solutions, not derivative work. Use when designing features, architecting software, brainstorming apps, reviewing designs, or during strategy discussions. Focuses on first-principles thinking, simplicity where it matters, and creating rather than commenting.
50
54%
Does it follow best practices?
Impact
—
No eval scenarios have been run
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./renaissance-architecture/skills/renaissance-architecture/SKILL.mdQuality
Discovery
67%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
The description has good structural completeness with an explicit 'Use when...' clause and covers both what and when. However, it is broad in scope, mixing software architecture, UI/UX, brainstorming, and strategy, which creates overlap risk with other skills. The philosophical language ('first-principles thinking', 'creating rather than commenting', 'not derivative work') adds flavor but doesn't translate into concrete, distinguishable capabilities.
Suggestions
Narrow the scope or add more specific concrete actions (e.g., 'designs system architectures, creates wireframes, evaluates tech stack tradeoffs, maps user flows') to improve specificity and distinctiveness.
Add more natural trigger terms users would actually say, such as 'system design', 'wireframe', 'prototype', 'tech stack', 'UX flow', 'component architecture', or 'design patterns'.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (software architecture, UI/UX) and some actions (designing features, architecting software, brainstorming apps, reviewing designs), but the actions are fairly broad and the description leans more toward philosophy ('first-principles thinking', 'creating rather than commenting') than concrete capabilities. | 2 / 3 |
Completeness | Clearly answers both 'what' (software architecture and UI/UX principles for building new solutions) and 'when' (explicit 'Use when...' clause listing designing features, architecting software, brainstorming apps, reviewing designs, strategy discussions). | 3 / 3 |
Trigger Term Quality | Includes some natural keywords users might say like 'designing features', 'architecting software', 'brainstorming apps', 'reviewing designs', and 'strategy discussions'. However, these are broad terms that could apply to many contexts, and it misses more specific variations users might use (e.g., 'wireframe', 'system design', 'tech stack', 'UX flow', 'prototype'). | 2 / 3 |
Distinctiveness Conflict Risk | The scope is quite broad—covering software architecture, UI/UX, brainstorming, design review, and strategy—which could easily overlap with coding skills, design system skills, or general brainstorming skills. The philosophical framing ('first-principles thinking', 'not derivative work') adds some distinctiveness but doesn't create a clear niche. | 2 / 3 |
Total | 9 / 12 Passed |
Implementation
42%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill provides a comprehensive philosophy for software architecture and design with useful decision tables and review checklists. Its main strengths are the concrete threshold triggers for complexity decisions and the structured review checklists. However, it suffers from significant repetition (the simplicity/complexity theme is restated 4-5 times), monolithic structure without progressive disclosure, and a lack of executable examples or validation workflows that would make it more actionable in practice.
Suggestions
Split into multiple files: keep SKILL.md as a concise overview with the core question, quick reference table, and review checklists, then reference separate files for architecture principles, UI/UX philosophy, and framework comparison details.
Remove repetitive content: the threshold triggers table, simplicity-as-default table, and pragmatic defaults section all convey the same information — consolidate into one authoritative table.
Add validation steps to the review workflow: specify what to do when a checklist item fails, how to document the decision, and when to escalate or revisit (e.g., 'If complexity isn't earned, document the simpler alternative in an ADR before proceeding').
Trim philosophical framing: the medieval scholars metaphor appears three times — use it once in the introduction and let the concrete guidance speak for itself.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is well-structured with tables that compress information efficiently, but it's quite long (~400 lines) with significant repetition. The threshold triggers table near the end largely duplicates the 'Simplicity as Default' table from the beginning. Philosophical framing (medieval scholars metaphor) is repeated multiple times. Some sections like 'What This Rejects' and 'Anti-Dogma Clause' overlap conceptually. However, it avoids explaining things Claude already knows (no 'what is SQLite' explanations). | 2 / 3 |
Actionability | The skill provides concrete decision tables and checklists (the review checklists are particularly actionable), but lacks executable code examples or specific commands. For an architecture/design philosophy skill, the guidance is reasonably concrete with clear decision criteria and threshold triggers, but some sections remain abstract ('build genuinely new things'). The checklists in the Application section are the most actionable elements. | 2 / 3 |
Workflow Clarity | The 'When Reviewing Designs' section provides clear checklists, and 'When Generating Solutions' gives a sequenced approach. However, there are no explicit validation checkpoints or feedback loops. For a design review workflow, there's no guidance on what to do when checks fail, how to iterate, or how to document decisions. The threshold triggers table helps but lacks a process for evaluating triggers. | 2 / 3 |
Progressive Disclosure | This is a monolithic ~400-line file with no references to external files or bundle resources. The content could benefit significantly from splitting into separate files (e.g., architecture principles, UI/UX philosophy, review checklists, framework comparison). There are no cross-references, no 'see X for more detail' pointers, and everything is inline despite the breadth of topics covered. | 1 / 3 |
Total | 7 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
2e2fa33
Table of Contents
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.