teach-impeccable

Overview of teach-impeccable skill

What teach-impeccable skill does

The teach-impeccable skill is a one-time setup workflow for capturing your project's design context and turning it into persistent guidance your AI can reuse later. Instead of repeatedly re-explaining brand, UX goals, visual direction, and design constraints in every session, teach-impeccable helps you inspect the repo first, ask only the missing questions, and save the answers into your AI config.

Who should use teach-impeccable

This skill is best for teams using AI for product design, UI implementation, or Context Engineering across an existing codebase. It is especially useful when:

• the repo already contains signals such as components, styles, tokens, or docs
• multiple sessions or agents need consistent design judgment
• you want the AI to stop inventing a visual direction from scratch each time

If you only need a one-off mockup prompt, teach-impeccable may be more setup than you need.

The real job-to-be-done

Users do not install teach-impeccable just to "document design." They install it to reduce repeated briefing, avoid inconsistent UI choices, and establish reusable design context early. The practical outcome is better downstream prompts because the AI starts from known brand and UX assumptions rather than generic taste.

What makes this different from a normal prompt

A normal prompt usually asks for design help immediately. The teach-impeccable skill is more disciplined:

1. inspect the codebase first
2. infer what can already be learned
3. ask targeted UX and brand questions only where the repo is silent
4. persist the result for future sessions

That makes it a better fit for Context Engineering than ad hoc prompting, because it front-loads durable context instead of redoing discovery every time.

What the repository actually provides

This skill is lightweight: the core guidance is in SKILL.md, with no extra scripts or resource folders to automate collection. That means adoption is easy, but output quality depends on how well you perform the repo scan and how specific your answers are when the skill asks follow-up questions.

How to Use teach-impeccable skill

teach-impeccable install context

Install the skill in the environment where your agent can access the target repository:

npx skills add pbakaus/impeccable --skill teach-impeccable

Because teach-impeccable install is meant as a setup pass, run it when you have enough repository context available: source files, styling system, docs, and any existing brand assets.

Read this file first

Start with:

• SKILL.md

This repository signal matters: there are no companion scripts, metadata files, or reference packs in the skill folder, so SKILL.md is the full operating manual.

What input teach-impeccable needs

For strong teach-impeccable usage, the skill needs two kinds of input:

• inferred context from the repo
• missing human context from the product owner or designer

Useful repo evidence includes:

• README.md or product docs
• package.json and framework config
• component libraries and UI primitives
• CSS variables, design tokens, theme files, spacing scales
• logos, favicons, and brand colors
• existing app screens or component patterns

How to run the workflow well

Use this sequence:

1. Scan the codebase for design and product signals.
2. Write down what is already clear.
3. List only what remains ambiguous.
4. Ask the user focused UX and brand questions.
5. Save the resulting design guidance into your AI config for reuse.

The skill is explicitly designed to avoid asking basic questions the repo already answers.

What questions the skill is trying to answer

From the source, teach-impeccable focuses on areas like:

• users and their context
• the job they are trying to get done
• target emotional tone
• brand personality
• reference products and anti-references
• aesthetic direction

This is a useful clue for adoption: the skill is not a pixel-level audit tool. It is a structured context-gathering pass for future design decisions.

Turn a vague goal into a strong prompt

Weak input:

• "Help set up design guidance for this app."

Better input:

• "Use teach-impeccable for Context Engineering on this repo. First inspect the component library, CSS variables, and README. Infer existing visual patterns and product purpose. Then ask me only the unanswered questions about users, brand personality, emotional tone, references, and anti-references. After that, produce persistent design guidance I can reuse in future sessions."

Why this works:

• names the repo areas to inspect
• tells the agent not to ask redundant questions
• defines the output as reusable guidance, not a chat answer

Example prompt for teach-impeccable usage

You can invoke the skill with a prompt like this:

Use teach-impeccable on this repository. Scan the README, theme files, shared UI components, and any design tokens first. Summarize what you can infer about product purpose, audience, current visual language, and constraints. Then ask me only the unresolved UX and brand questions. Finally, compile a persistent design-context brief suitable for future AI sessions.

What good answers from you look like

The quality of the saved guidance depends heavily on your replies. Strong answers are concrete:

• Brand personality: "calm, trustworthy, technical"
• Emotional goal: "users should feel in control, not dazzled"
• Reference: "Stripe Dashboard for clarity and hierarchy, not for color palette"
• Anti-reference: "avoid crypto-dark neon aesthetics"
• Audience: "operations managers using the tool under time pressure"

Specificity improves future AI behavior far more than broad labels like "modern" or "clean."

Best workflow after setup

After the first run, use the saved design context as a baseline for:

• UI implementation prompts
• design system extension
• component refactors
• content and interaction tone
• review prompts that check whether new work matches the established direction

This is where teach-impeccable for Context Engineering earns its value: it reduces re-briefing and design drift across sessions.

When the skill will feel weak

The skill can underperform if:

• the repo has little visible design evidence
• your product is still concept-stage with no code or style system
• the user cannot answer brand and audience questions clearly
• you expect the skill to generate a full design system automatically

In those cases, you may need a broader discovery prompt before teach-impeccable.

teach-impeccable skill FAQ

Is teach-impeccable worth installing for a small project

Yes, if you expect repeated AI-assisted design or UI work. Even a small project benefits when the AI remembers audience, tone, and visual constraints. For a one-off page or experiment, ordinary prompting may be enough.

Is teach-impeccable beginner-friendly

Mostly yes. The process is simple: inspect the repo, ask focused questions, save the result. The main challenge is not installation but answering design questions with enough specificity to be useful later.

How is this different from writing one big brand prompt

A one-off prompt is easy to start but easy to lose. The teach-impeccable guide is about creating persistent, reusable context anchored in the actual codebase. That usually leads to more consistent follow-on outputs than repeatedly pasting a long design brief.

Does teach-impeccable replace a designer

No. It captures and structures design intent; it does not replace product judgment. Its best use is helping agents and collaborators work from the same design context.

When should I not use teach-impeccable

Skip it when:

• there is no meaningful repo or product context yet
• you need quick ideation, not persistent guidance
• the project direction is still intentionally open-ended
• your team is not ready to define audience, tone, or visual constraints

Does the repository include automation or helper assets

No major helper files are surfaced beyond SKILL.md. That keeps the skill lightweight, but also means the operator must do the repository reading and context synthesis carefully.

How to Improve teach-impeccable skill

Give teach-impeccable better source material

Before running teach-impeccable, make sure the repo exposes signals the skill can use:

• document product purpose in README.md
• keep tokens and themes discoverable
• centralize reusable components
• preserve logos, colors, and naming conventions in the repo

The more the agent can infer directly, the fewer generic questions it needs to ask.

Answer with examples, not adjectives

Common weak answer:

• "We want it to feel modern."

Better answer:

• "We want restrained enterprise polish: neutral surfaces, strong hierarchy, clear forms, minimal ornament, and no playful illustration."

This improves the skill because future sessions can translate examples into actionable design choices.

Be explicit about anti-goals

One of the highest-leverage improvements is telling teach-impeccable what to avoid:

• "not gamified"
• "not luxury editorial"
• "not startup gradient-heavy"
• "not consumer-social"

Negative boundaries often guide AI outputs more reliably than positive style labels alone.

Include user context, not just brand context

A common failure mode is over-specifying aesthetics while under-specifying users. Better inputs include:

• who the user is
• what pressure they are under
• how often they use the product
• what mistakes are costly
• what confidence signals matter

That gives teach-impeccable skill a stronger basis for UX decisions, not just surface styling.

Review the first saved guidance critically

After the first pass, check whether the persisted design brief contains:

• audience and task context
• emotional tone
• visual direction
• references and anti-references
• constraints inferred from the existing codebase

If it reads like generic design advice, rerun with more concrete answers and more repo evidence.

Improve iteration after the first output

A strong refinement prompt looks like this:

Revisit the teach-impeccable output. Tighten any vague guidance, remove generic style language, and make the brief more actionable for future UI implementation. Emphasize the user's working context, visual anti-patterns to avoid, and any constraints already visible in the codebase.

This helps convert broad taste statements into durable instructions.

Watch for these failure modes

Typical problems include:

• asking the user questions the repo already answers
• storing abstract style words without examples
• ignoring existing design tokens or component conventions
• mixing product strategy questions with visual design setup
• writing guidance too loosely to influence future outputs

If you see these, the fix is usually better repo scanning and sharper user answers, not more verbosity.

Use teach-impeccable as foundation, not finish line

The best way to improve teach-impeccable for Context Engineering is to treat it as the baseline context layer. After setup, create follow-on prompts for implementation, critique, accessibility, or design system work that explicitly build on the saved design guidance instead of starting over.