How to Use the Dimma Framework with AI Code Generators

Why Does AI-Generated Front-End Code Need Design Pattern Constraints?

AI coding assistants are remarkably capable but consistently produce two types of problematic code: over-engineered solutions (YAGNI violations — configuration options nobody asked for, generic abstractions for hypothetical use cases) and god components (SRP violations — a single hook that fetches, validates, formats, and manages state).

The root cause is vague prompts. 'Write a clean React hook for user registration' gives the AI no constraints. It doesn't know if you want a thin client display hook or a fat client business logic module. It doesn't know your team's complexity budget.

The Dimma Framework gives you the precise vocabulary to constrain AI output.

How Do You Write Pattern-Specific AI Prompts?

Replace vague instructions with principle-named constraints:

Bad prompt: 'Write a clean custom hook for order management.'

Good prompt: 'Create a React hook called useOrderValidation with a single responsibility: validating order form fields (item count > 0, shipping address not empty). It should NOT handle API calls, submission state, or data fetching — those are separate hooks. Keep it simple: use useState, not useReducer. Do not add configuration options for validation rules I haven't specified.'

This prompt applies SRP (single responsibility: validation only), KISS (useState over useReducer), YAGNI (no extra config), and implicitly DIP (no API calls inside the validation hook).

The AI now has clear boundaries. The output is testable, focused, and appropriate for your actual needs.

How Do You Review AI-Generated Code Using the Framework?

Run every AI-generated component through this checklist:

1. SRP check: How many reasons could this change? If more than one, ask the AI to split it.

2. YAGNI check: Did the AI add parameters, options, or abstractions you didn't ask for? Remove them.

3. KISS check: Did the AI use useReducer when useState works? Did it reach for a complex library when a simpler one suffices?

4. DRY check: If the AI generated similar code across multiple files, is it shared knowledge or coincidental similarity?

5. DIP check (fat clients only): Does the business logic hook directly import API functions? Ask the AI to separate them.

This takes 60 seconds and prevents the most common AI code problems from reaching your codebase.

How Do You Iterate on AI Output Using Pattern Language?

When the first AI output isn't right, give pattern-specific follow-up instructions:

- 'This hook violates SRP — split the data fetching into useOrderData and the validation into useOrderValidation.'

- 'This violates YAGNI — remove the locale and timezone parameters from formatDate, I only need formatDate(date).'

- 'This violates OCP — instead of adding another branch to the switch statement, extract each shipping type's cost calculation into its own function and pass it as a callback.'

Pattern-named instructions produce dramatically faster convergence than 'make it better' or 'simplify it.'

What's the Next Step?

Take your most recent AI-generated component and run it through the 5-point checklist above. Identify one specific violation, then re-prompt the AI using the principle name and a concrete instruction. Compare the before and after. You'll see the difference immediately.