AI-Powered Spec-Driven Development Guide

## Prompt to AI (Claude, ChatGPT, Gemini)

You are a senior business analyst specializing in diamond and jewellery
inventory management software.

I will provide interview notes about the "Diamond Purchase Entry"
feature. Generate a complete feature specification using this template:

[Paste your spec template here]

Key context:
- Modernization: WinForms + WCF → React + .NET Core
- Frontend uses AG Grid for tabular data entry
- Handles both loose diamonds and certified diamonds
- Weights in carats (up to 3 decimal places)
- Currency: INR with USD conversion rates
- Party (supplier) master data already exists

Interview Notes:
"""
Rajubhai explained the purchase entry process:
- When broker brings diamonds, first we check the lot
- Each stone has shape, size, color, clarity, cut
- For certified stones, enter GIA/IGI certificate number
- Rate can be per carat or per piece (for small sizes)
- Making charges apply only to jewellery, not loose diamonds
- Track broker commission (usually 0.5-1%)
- Purchase can be "on memo" (approval) or "firm purchase"
- GST: 0.25% on diamonds, 3% on gold jewellery
- Party outstanding gets updated after saving
- Need to print purchase voucher after saving
"""

Generate the complete specification with all fields filled in.
Make sure business rules are numbered and testable.

## Prompt to AI

I am modernizing a WinForms application to React + .NET Core.
Below is legacy code for the Purchase Entry form and WCF service.

Analyze and extract a complete feature specification:

1. Identify all business rules embedded in the code
2. Document the data model (fields, types, validations)
3. Map UI behaviors (grid columns, calculated fields, events)
4. List all edge cases handled in the code
5. Note hard-coded values that should become configurable

Format using our spec template.

Legacy Code:
[Paste the relevant WinForms .cs file here]

## Prompt to your AI coding assistant (VS Code / Cursor)

Based on the following spec section, generate AG Grid column
definitions for the Diamond Purchase Entry grid.

Requirements from spec:
- Columns: Sr No (auto), Shape (dropdown), Size (text),
  Pcs (number), Carat (number, 3 decimals),
  Rate (number, 2 decimals), Amount (calculated: Carat × Rate),
  Certificate No (text, optional), Color, Clarity (dropdowns)
- Amount auto-calculates when Rate or Carat changes
- Shape, Color, Clarity use master data dropdowns
- Certificate No: validate "GIA-XXXXXXXXXX" or "IGI-XXXXXXX"
- Carat should not exceed 99.999
- Tab → next editable cell; Enter on last row → new row

Generate ColDef[] with proper TypeScript types and
AG Grid Enterprise features.

# Diamond & Jewellery Inventory — Frontend
# React 18 + TypeScript 5 + AG Grid Enterprise

## Tech Stack
- React 18 with functional components and hooks only
- TypeScript strict mode — always provide explicit types
- AG Grid Enterprise for all tabular data
- React Hook Form + Zod for validation
- TanStack Query for server state
- Zustand for client state
- Axios with interceptors for .NET Core backend

## Coding Standards
- Named exports, not default exports
- Component files: PascalCase (PurchaseEntryGrid.tsx)
- Hooks: camelCase with "use" prefix (usePurchaseEntry.ts)
- Never use `any` — use `unknown` + type guards
- `const` assertions for AG Grid column definitions

## Domain Context
- Memo / Jangad: Consignment/approval — stones on approval
- Packet: Group of small diamonds traded as unit
- Party: Business entity (supplier, customer, broker)
- Carat: Weight unit — always 3 decimal places
- 4C: Cut, Color, Clarity, Carat — grading params

## AG Grid Patterns
- Always use ColDef<T> with generic type param
- `valueGetter` for computed columns
- Indian numbering for currency (₹1,23,456.78)
- 3 decimal places for weight columns
- Keyboard nav: Tab, Enter, Escape
- Editable grids must support undo/redo

## File Structure
src/
├── features/        # Feature-based modules
│   ├── purchase/    │   ├── sale/
│   ├── memo/        │   ├── stock/
│   └── masters/
├── components/      # Shared components
├── hooks/           # Shared hooks
├── services/        # API layer
├── types/           # Shared TypeScript types
└── utils/           # Utilities

# Diamond & Jewellery Inventory — Backend
# .NET 8 (LTS) + EF Core + SQL Server

## Architecture
- Clean Architecture: Domain → Application → Infrastructure → API
- CQRS with MediatR for commands and queries
- Repository pattern with Unit of Work over EF Core
- FluentValidation for all command/query validation
- AutoMapper for entity-to-DTO mapping

## Coding Standards
- C# 12, nullable reference types enabled
- `record` types for DTOs and value objects
- `sealed` on classes not meant to be inherited
- Async/await throughout — no `.Result` or `.Wait()`
- `decimal` for monetary values & weights (never `double`)
- API versioning: `/api/v1/`

## Domain Types
- Carat Weight: `decimal(8,3)` in SQL, `decimal` in C#
- Monetary amounts: `decimal(18,2)`
- Exchange rates: `decimal(10,4)`
- Primary keys: `Guid` not `int`

## Business Rules in Code
- Rules live in Domain layer service classes
- Name methods after rule: ApplyBR004_CalculateGST()
- Include rule ID in XML doc comments
- Throw DomainException for violations

## Project Structure
src/
├── DiamondJewel.Domain/
├── DiamondJewel.Application/
├── DiamondJewel.Infrastructure/
├── DiamondJewel.API/
└── tests/
    ├── DiamondJewel.Domain.Tests/
    ├── DiamondJewel.Application.Tests/
    └── DiamondJewel.API.Tests/

# Diamond & Jewellery Industry Glossary

## Transaction Types
| Term           | Local Term     | Meaning                              |
|----------------|---------------|--------------------------------------|
| Purchase       | Kharidi        | Buying from a supplier               |
| Sale           | Vechan         | Selling to a customer                |
| Memo           | Jangad         | Stones sent on approval basis        |
| Memo Return    | Jangad Parat   | Getting back unsold stones           |
| Memo Convert   | Jangad Sale    | Converting memo to confirmed sale    |
| Rejection      | Rejection      | Returning stones due to quality      |

## Diamond Grading (4C)
| Param     | Values                                              |
|-----------|-----------------------------------------------------|
| Shape     | Round, Princess, Oval, Cushion, Emerald, Pear, ...  |
| Color     | D, E, F, G, H, I, J, K, L, M, N-Z                  |
| Clarity   | FL, IF, VVS1, VVS2, VS1, VS2, SI1, SI2, I1-I3      |
| Cut       | Ideal, Very Good, Good, Fair, Poor                  |

## Weight & Pricing
- 1 Carat = 0.2 grams. Precision: 3 decimal places
- Points: 1 carat = 100 points (50-pointer = 0.50ct)
- Rapaport: Industry benchmark price list (USD/ct)
- Discount%: Actual price as discount to Rapaport

## Tax (India GST)
- Diamonds (rough & polished): 0.25% (HSN: 7102)
- Gold Jewellery: 3% (HSN: 7113)
- Making/Labour: 5%
- Intra-state: split CGST + SGST. Inter-state: IGST

# AG Grid Patterns — Diamond Inventory System

## Currency Column (Indian Format)
```typescript
export const currencyColumn = (
  field: string, header: string
): ColDef => ({
  field, headerName: header,
  type: 'numericColumn',
  valueFormatter: (p) => p.value != null
    ? '₹' + new Intl.NumberFormat('en-IN', {
        minimumFractionDigits: 2,
        maximumFractionDigits: 2,
      }).format(p.value)
    : '',
  cellStyle: { textAlign: 'right' },
  width: 140,
});
```

## Carat Weight Column (3 Decimals)
```typescript
export const caratColumn = (
  field: string, header: string
): ColDef => ({
  field, headerName: header,
  type: 'numericColumn',
  valueFormatter: (p) =>
    p.value != null ? p.value.toFixed(3) : '',
  cellEditor: 'agNumberCellEditor',
  cellEditorParams: {
    precision: 3, min: 0,
    max: 99.999, step: 0.001,
  },
  width: 110,
});
```