teach-impeccable

Overview of teach-impeccable skill

What teach-impeccable does

The teach-impeccable skill is a one-time setup workflow for AI-assisted UI design. It helps an agent inspect your codebase, identify existing design signals, ask only the missing UX questions, and then persist the resulting guidance into your AI config for future sessions. In practice, teach-impeccable is less about generating screens immediately and more about establishing durable design context the model can reuse.

Who should use teach-impeccable

This skill is best for teams and solo builders who already have a product, prototype, or codebase and want more consistent UI design help from their AI tool. It is especially relevant if you want teach-impeccable for UI Design to reflect your actual brand, audience, and current component patterns instead of starting from generic “modern SaaS” assumptions.

The real job to be done

Most users do not need another prompt that says “make this prettier.” They need an AI to learn:

• what the product is
• who it serves
• what visual cues already exist
• what design direction to avoid
• how to stay consistent across future tasks

teach-impeccable addresses that setup problem. It front-loads discovery so later UI requests are less repetitive and less likely to drift.

What makes this skill different

The main differentiator is the sequence:

1. inspect the repository first
2. ask targeted UX questions only where the codebase is ambiguous
3. save the resulting design guidance for future sessions

That makes the teach-impeccable skill more useful than a generic design prompt when your product already has partial design intent hidden in code, docs, tokens, or assets.

When it is a strong fit

Use teach-impeccable if you have any of the following:

• an existing app with components, CSS variables, or design tokens
• a repo with brand clues but no formal design system
• repeated frustration that AI outputs change style from session to session
• a need to align AI-generated UI with product purpose and audience

When it is not the right tool

Skip this skill if you want a finished UI concept from a blank slate in one step. It is not a replacement for detailed screen-by-screen design direction. It is also less valuable if your project has no meaningful repository context yet, because the first half of the workflow depends on codebase evidence.

How to Use teach-impeccable skill

teach-impeccable install context

The repository does not expose a separate installer inside SKILL.md, so the practical teach-impeccable install path is to add the skill from the GitHub source in your skills-enabled environment, for example:

npx skills add https://github.com/pbakaus/impeccable --skill teach-impeccable

Use it in a workspace where the AI agent can read your project files. The skill is explicitly marked user-invocable, so you should be able to call it directly by name in a compatible setup.

What the skill needs before you run it

teach-impeccable usage is strongest when the repo already contains some design evidence. Helpful inputs include:

• README.md or product docs
• package.json and framework config
• component folders
• global styles
• CSS variables or token files
• logos, icons, favicons, or brand assets
• any prior design references

If those do not exist, the agent will have less to infer and will rely more heavily on your answers.

The actual workflow inside teach-impeccable

The skill follows a simple but important sequence:

1. scan the codebase for product and design context
2. note what is clear versus missing
3. stop and ask UX-focused questions
4. gather answers about users, brand personality, references, and aesthetic preferences
5. persist this design context for future sessions

The stopping point matters. A good agent should not rush from repo scan straight into design output without clarification.

What to tell the agent when invoking it

A weak invocation is:

• “Use teach-impeccable.”

A stronger invocation is:

• “Use teach-impeccable on this app. Inspect the repo for existing UI patterns, brand signals, and tokens first. Then ask me only the design questions the code cannot answer, and save the resulting design guidance for future sessions.”

That prompt reinforces the intended order and reduces the chance that the agent skips discovery.

How to prepare better answers

The questions in the skill center on:

• users and usage context
• product purpose
• emotional tone
• brand personality
• reference products
• anti-references
• overall aesthetic direction

Good answers are specific and comparative. For example:

Instead of:

• “Clean and modern.”

Provide:

• “Primary users are small business owners checking cash flow on mobile between meetings. The UI should feel calm, trustworthy, and efficient. We like Linear’s restraint and Stripe’s clarity, but do not want a glossy crypto-dashboard look.”

That gives the model usable constraints, not adjectives it can interpret too broadly.

How to turn a rough goal into a complete teach-impeccable prompt

If your real goal is “help me redesign the dashboard,” first run teach-impeccable with context like:

• what the dashboard is for
• who uses it most
• what decisions users need to make quickly
• what visual traits would build trust
• what existing UI should remain recognizable

Then, after the skill saves persistent guidance, ask for the redesign. This two-step flow usually outperforms asking for redesigns cold.

Best repository files to inspect first

For this repository, start with:

• SKILL.md

For your own project, the agent should inspect:

• README.md
• package.json
• app shell and layout files
• design system or component directories
• theme files
• CSS variable definitions
• asset folders

The teach-impeccable guide is intentionally light on support files, so most of the value comes from how well the agent reads your repo before asking questions.

What persistence means in practice

The skill description says it saves design context to your AI config file for future sessions. That is the core adoption benefit: you do the design briefing once, then later tasks can inherit those guidelines. If your tooling does not actually persist session guidance, the value of teach-impeccable skill drops, because you would need to repeat the setup manually.

Common usage pattern that works well

A practical workflow is:

1. run teach-impeccable once per project or major redesign
2. answer the clarification questions carefully
3. verify the saved guidance reflects your product accurately
4. use that context for later tasks like component design, visual cleanup, or UX refinement
5. rerun the skill if the brand, audience, or design direction changes substantially

Tradeoffs to know before adoption

The skill is intentionally narrow. It does not ship with scripts, rules, reference packs, or examples. That makes it easy to understand, but it also means output quality depends heavily on:

• how much design signal exists in the repo
• whether the agent follows the stop-and-ask step
• how concrete your answers are
• whether your environment truly stores the captured guidance

teach-impeccable skill FAQ

Is teach-impeccable better than a normal design prompt

Usually yes, if you have an existing product. A normal prompt often ignores codebase clues and produces generic styling. teach-impeccable is better when you want design work grounded in current components, tokens, and brand intent.

Is teach-impeccable good for beginners

Yes, with one caveat: beginners still need to answer product and brand questions clearly. The skill reduces prompt-writing guesswork, but it cannot invent a coherent design direction if you do not know your users, tone, or aesthetic boundaries.

Does teach-impeccable generate final UI designs by itself

Not really. The teach-impeccable skill is primarily a setup layer. Its job is to gather and save design context so later UI design requests are more consistent and less generic.

When should I not use teach-impeccable

Do not use it as your first step on a project with no repo, no audience definition, and no product clarity. In that case, you need product discovery or direct concept prompting first. It is also overkill for a one-off visual tweak you do not plan to revisit.

What kind of projects fit teach-impeccable for UI Design

It fits best on apps, dashboards, websites, and product interfaces where brand consistency matters over time. It is especially useful when the repo contains partial UI decisions already but nobody has documented them well.

Does the repository include extra automation or reference assets

No major support folders are surfaced here. There are no visible rules/, resources/, or helper scripts in the skill path preview. That means adoption is simple, but the skill relies more on agent behavior and your project context than on bundled assets.

How to Improve teach-impeccable skill

Give teach-impeccable better evidence to work from

The fastest way to improve teach-impeccable usage is to make sure your repo exposes real design signals:

• keep token names meaningful
• centralize colors and typography
• document product purpose in README.md
• store logos and brand assets in predictable places
• avoid scattering key visual decisions across many files

The easier your codebase is to read, the more accurately the skill can infer your design baseline.

Answer with constraints, not taste words

Common failure mode: users respond with vague words like “premium,” “simple,” or “modern.” Those are too open-ended. Improve results by pairing every taste word with context:

• who the user is
• what they are trying to do
• what emotion matters
• what references capture the direction
• what should be avoided

This makes teach-impeccable produce guidance that is actually reusable later.

Be explicit about anti-patterns

One of the highest-leverage improvements is to state what the interface should not resemble. Good anti-references help the model avoid drift. For example:

• “Avoid neon gradients and crowded analytics-dashboard aesthetics.”
• “Do not make this feel playful or consumer-social.”
• “Avoid oversized marketing-site hero patterns inside the product UI.”

Verify the saved guidance after the first run

Do not assume the persisted context is correct. After running teach-impeccable, inspect the saved design guidance and check:

• core audience
• brand personality
• reference cues
• anti-references
• visual tone
• consistency with current product reality

If these are wrong, every later UI task inherits the error.

Rerun the skill when the product changes

The best time to refresh teach-impeccable skill is after:

• a rebrand
• a new target audience
• a major product pivot
• a design system overhaul
• a shift from prototype to production polish

Persistent context is powerful, but stale context is dangerous.

Use a two-pass workflow for stronger downstream output

For better results, separate setup from design execution:

1. run teach-impeccable
2. confirm the stored guidance
3. ask for a specific artifact such as a settings page refresh or component cleanup
4. iterate with screenshots, code, or user feedback

This avoids mixing discovery and execution in one noisy request.

Correct common failure modes early

Watch for these signs that the skill run was too weak:

• the agent asked broad questions answerable from the repo
• it skipped asking questions entirely
• the saved guidance sounds generic
• later UI outputs ignore your existing patterns
• design suggestions feel trendy rather than product-specific

If you see these, rerun with a stronger invocation and more concrete answers.

Pair the skill with concrete follow-up tasks

After setup, ask for bounded tasks such as:

• refine spacing and typography in the dashboard
• align a form flow with the stored brand tone
• update a component library to match saved design principles
• review UI consistency against the persisted guidance

That is where the value of teach-impeccable guide becomes visible: not in the initial questions alone, but in the improved consistency of future work.