Assistant Presets

# Assistant Presets

Part of [Agent Skills™](https://github.com/itallstartedwithaidea/agent-skills) by [googleadsagent.ai™](https://googleadsagent.ai)

## Description

Assistant Presets provides a framework for creating, testing, and deploying specialized AI assistant configurations for domain-specific tasks. Each preset encapsulates a system prompt, model parameters, tool access permissions, output format constraints, and quality benchmarks into a reusable, versionable artifact that transforms a general-purpose LLM into a domain expert.

A bare LLM is a generalist. A well-crafted preset turns it into a specialist: a legal contract reviewer that flags liability clauses, a medical triage assistant that follows diagnostic protocols, a code reviewer that enforces team conventions, or a customer support agent that follows the company's tone guide. The difference between a useful AI assistant and a frustrating one is almost entirely in the preset configuration.

This skill codifies the process of building high-quality presets: defining the persona and constraints, writing few-shot examples, specifying output formats, selecting appropriate model parameters (temperature, top-p, max tokens), and validating against a benchmark of expected inputs and outputs. Presets are version-controlled and A/B tested before deployment.

## Use When

- Creating domain-specific AI assistants (legal, medical, finance, code review)
- Standardizing AI behavior across a team or organization
- Building a library of reusable assistant configurations
- Optimizing system prompts for specific use cases
- A/B testing different assistant configurations
- The user asks for a "custom assistant", "persona", or "system prompt"

## How It Works

```mermaid
graph TD
    A[Define Domain + Task] --> B[Write System Prompt]
    B --> C[Add Few-Shot Examples]
    C --> D[Configure Parameters]
    D --> E[Define Output Format]
    E --> F[Create Benchmark Dataset]
    F --> G[Evaluate Against Benchmark]
    G --> H{Quality Threshold Met?}
    H -->|No| I[Iterate on Prompt]
    I --> B
    H -->|Yes| J[Version + Deploy]
    J --> K[A/B Test in Production]
    K --> L[Monitor + Maintain]
```

The preset development cycle is iterative: write, benchmark, refine. Each iteration is versioned so regressions can be detected and reverted. Production presets are A/B tested against the previous version to verify improvement.

## Implementation

```typescript
interface AssistantPreset {
  id: string;
  version: string;
  name: string;
  description: string;
  domain: string;
  systemPrompt: string;
  fewShotExamples: Array<{ input: string; output: string }>;
  parameters: {
    model: string;
    temperature: number;
    topP: number;
    maxTokens: number;
    stopSequences?: string[];
  };
  outputFormat: {
    type: "text" | "json" | "markdown" | "structured";
    schema?: Record<string, unknown>;
  };
  tools: string[];
  guardrails: {
    maxResponseLength: number;
    blockedTopics: string[];
    requiredDisclaimer?: string;
  };
}

const codeReviewPreset: AssistantPreset = {
  id: "code-review-v3",
  version: "3.1.0",
  name: "Code Reviewer",
  description: "Reviews code for correctness, security, and maintainability",
  domain: "software-engineering",
  systemPrompt: `You are a senior code reviewer. Review the provided code diff with these priorities:
1. Correctness: Does it do what it claims?
2. Security: Are inputs validated? Secrets protected?
3. Performance: Any obvious bottlenecks?
4. Maintainability: Clear naming? Reasonable complexity?

Format findings as:
- [SEVERITY] file:line - Description
- Suggested fix: ...

Severities: CRITICAL, HIGH, MEDIUM, LOW`,
  fewShotExamples: [
    {
      input: "```diff\n+const data = JSON.parse(userInput)\n```",
      output: "[CRITICAL] app.ts:1