crontent

How to Make Claude Match Your Existing SaaS

A new settings page shouldn't introduce another button style. If you've already shipped a SaaS product, start Claude with the interface you have, not an invitation to invent a different one.

Your goal is a page that looks familiar, handles awkward data, and works beyond a tidy screenshot. A reusable design brief can make those expectations explicit.

This guide uses “design skill” to mean reusable instructions for Claude. It's a proposed workflow for your product, not a review of a downloadable skill or a guide to a specific installation method.

What are Claude design skills?

A Claude design skill, for this workflow, is a reusable set of instructions that tells Claude how to work within your product's existing interface.

Instead of asking for “a clean settings page,” you supply the rules that make a settings page belong in your app. Those rules should describe actual code and visible behavior, rather than a mood.

A useful starting brief answers these questions:

  • Which existing pages should the new work resemble?
  • Which components should Claude reuse?
  • Where do the fonts, colors, and spacing rules live?
  • Which screen states must the work include?
  • What should Claude check before calling the task finished?

Teach Claude your existing product before asking it to design another page.

For a shipped SaaS, that's the central job. You're adding to something customers already use. A new visual direction should be a deliberate choice, not a side effect of an underspecified prompt.

Keep the distinction between instructions and setup clear. Writing a markdown file doesn't, by itself, establish that Claude will automatically load it. Use whatever method your Claude setup supports to provide the instructions, and confirm that the relevant context is available.

You can start with a document you paste into the task. You can also keep a version alongside your code and explicitly ask Claude to read it. Check your setup's documentation before treating that file as an automatically loaded skill.

The useful question isn't whether you've found the perfect skill name. It's whether Claude has enough accurate context to extend your product without guessing at its basic rules.

Build the rules from your shipped interface

Your Claude design instructions should name real components and reference real screens from your product.

Open a page you're happy to repeat. Find its layout, typography, buttons, fields, and spacing in the code. Record where those choices come from. If the code and screenshot disagree, decide which one should guide the new work.

Build a small reference pack:

  • Screenshots: a full page and any important detail Claude should match.
  • Components: the existing controls and layouts relevant to the task.
  • Styles: the actual font, color, and spacing definitions.
  • Behavior: examples of validation, loading, and saved changes.

Don't invent a neat system just to fill out the document. If your app has inconsistent spacing, say which existing page is the reference for this task. If you haven't settled dark mode, don't imply that you have.

Write concrete rules. “Use the existing settings layout” is better than “make it feel premium.” Point to the real layout file rather than leaving Claude to infer which settings page you mean.

Pair screenshots with instructions about what matters. For example: “Match this page's content width and field spacing. Keep its plain background. The account details are sample content.” That separates visual rules from incidental details.

Keep secrets and customer data out of the reference pack. Use a safe account or redact screenshots before sharing them.

For a solo builder, the brief doesn't need to become a separate documentation project. Start with enough detail for one real page. Add a rule when a review exposes an important gap, rather than documenting every corner of the app before doing useful work.

Require Claude to inspect and reuse components

Tell Claude to find an existing component before creating another button, card, or form control.

Make that instruction part of the design brief, then repeat the relevant boundary in the task. “Reuse existing components” leaves room for interpretation. “Inspect the account page and use its field and button components” gives Claude a concrete place to start.

A working instruction could read:

Before editing, identify the existing layout and controls that fit this task. Reuse them where they support the required behavior. If you need a new component, explain what the existing ones can't do. Don't create a page-specific copy just to change its appearance.

Don't turn reuse into a ban on new code. A new interaction may need a new component. You want a reason for that component, not a forced fit that makes the existing code harder to understand.

Review the diff with a narrow set of questions:

  • Did Claude recreate a control that already exists?
  • Did it add local colors or spacing instead of using the current styles?
  • Did it change a shared component for a need specific to this page?
  • Did it add an option that should live in an existing component?

Ask Claude to explain those choices, but inspect the code yourself. A claim that something was reused isn't the same as seeing the import and its use.

Keep unrelated cleanup outside the task unless it blocks the work. When you ask for a settings page, you should be able to review a settings-page diff. If Claude proposes replacing shared styles, pause and decide whether you actually want that larger change.

Specify loading, empty, error, and success states

A settings-page brief should describe what users see before data arrives, when data is missing, and after saving fails or succeeds.

Don't leave those states inside an instruction like “handle edge cases.” Name the situations that apply to the feature and say what the user should be able to do.

For an account settings task, give Claude a checklist:

  • Loading: show a clear waiting state while fetching existing settings.
  • Empty: explain what happens when an optional value hasn't been added.
  • Error: describe validation failures and failed save requests separately.
  • Success: show that the save finished without making the result ambiguous.

Also define what happens to the user's input. Should a failed request preserve their changes? Can they retry? Should the save button accept another click while a request is running? Those are product decisions. Give Claude your answers instead of asking it to guess.

Use the behavior your app already has where it makes sense. If other forms show errors beside the relevant field, ask for the same treatment. If the app uses a shared notice for failed requests, point to it.

Ask for a way to inspect each state during development. That might use existing fixtures or another method your project already supports. Don't accept a claim that the error state looks right if nobody has triggered it.

Keep the scope honest. A static interface with a success message isn't proof that settings were saved. If the task only covers the interface, label the unfinished behavior clearly.

Your design instructions should make those boundaries visible. A polished screen is useful, but it shouldn't hide which parts still depend on real data or unfinished code.

Check narrow screens, keyboard use, and long text

A screenshot can't show whether a keyboard user can reach the save button or whether a long account name breaks the layout.

Require Claude to check those cases where its tools allow it. Where it can't run the app or interact with the page, require an explicit handoff for you to check. Don't let “looks good” stand in for a test report.

Use your product's existing screen sizes as the starting point. Inspect a narrow layout as well as the wider view. Look for clipped labels, controls that overlap, and page sections that need awkward horizontal scrolling.

Then put the mouse aside. Move through the form with the keyboard and inspect the order. Make sure you can tell which control has focus. Try submitting the form and recovering from an error without clicking.

Test content that doesn't flatter the design:

  • A long account or company name.
  • An email address that needs more room than the sample.
  • Missing optional details.
  • An error message that wraps onto another line.

Ask Claude to preserve the meaning of the content rather than silently cutting it to fit. If truncation is intentional, decide how someone can read the full value.

Keep the final report specific. “Checked the narrow layout and fixed the clipped save button” tells you something. “Fully responsive and accessible” claims far more than a quick review can establish.

These checks don't amount to a complete accessibility audit. They are concrete acceptance checks for the page you're shipping. Put them in the reusable instructions so the next task starts with the same expectations, rather than depending on what you remember to ask that day.

Test the skill on a real settings-page task

Compare Claude's work on the same settings-page request with and without your reusable design instructions.

Treat it as a small local test, not proof that a particular skill always improves output. You want to know whether your instructions remove work from your review queue.

Choose a task with a clear boundary. For example, add an account settings page using existing fields and a save action. Define the same requirements for both attempts, and start from the same code state.

Run each attempt separately so earlier changes don't become hidden context for the next one. Keep the Claude setup and available tools as similar as you can. Record any differences you couldn't control.

Review both results against the same checklist:

  • Did the page use the intended components and styles?
  • Did it include the required screen states?
  • Did narrow layouts and long text behave acceptably?
  • Could you complete the form using a keyboard?
  • What did you have to fix before you would ship it?

Count concrete fixes if that helps you compare. Separate a duplicate button component from a missing error state. Don't collapse everything into an invented quality score.

Also record the work needed to prepare and maintain the instructions. A long brief that saves no review effort isn't earning its place in your process.

If the instructed attempt misses something important, change the smallest relevant rule and test again. Don't respond by adding a wall of vague demands to “make everything excellent.”

A useful result is modest and specific: the instructions helped Claude reuse the right form controls, but you still had to fix keyboard focus. That tells you what to keep and what to check next time.

Keep the skill small enough to use on every change

A reusable Claude design brief should contain current product rules, while each task supplies its own requirements.

Keep stable guidance separate from the page request. Your shared components, visual references, and review expectations belong in the reusable instructions. The fields for today's settings page belong in today's task.

That gives you a short prompt you can adapt:

Read the product design instructions and inspect the referenced settings page. Add the requested account settings fields using existing components. Include loading, empty, error, and success behavior where relevant. Check narrow layouts, keyboard use, and long content. Report what you changed, what you tested, and anything you couldn't verify.

Replace general references with the actual files and requirements before using it. The prompt should point Claude toward evidence in your product, not send it searching for an imaginary design system.

When you approve a change to a shared component, update the instructions if they now describe the wrong behavior. Remove stale screenshots. Don't make Claude choose between an old reference and the code you currently ship.

Keep the final handoff tied to evidence. Review the diff, open the page, and repeat the checks that matter for the change. If you later share the work in a product update, distinguish a working feature from a visual preview.

The test is how much work remains before you can safely ship. A screenshot alone can't answer that.

For your next page, pick one existing screen as the reference. Name its components, write down the required states, and give Claude the same checks you'll use in review. Run that task before spending an afternoon collecting more design skills.