Anthropic koopt Stainless: wat dit betekent voor jouw SDK met Claude Code

Anthropic koopt de SDK-fabriek van het internet

Gisteren maakte TechCrunch bekend dat Anthropic Stainless heeft overgenomen, het New Yorkse startup dat gespecialiseerd is in het automatisch bouwen en onderhouden van SDK's. Stainless genereerde al SDK's voor OpenAI, Google en Cloudflare. Nu gaat die kennis dus direct richting Anthropic en Claude Code.

Wat is een SDK? Simpel gezegd: een nette bibliotheek waarmee andere developers jouw product kunnen aanroepen vanuit hun eigen code. Denk aan openai.chat.completions.create(...) in Python, maar dan voor jóuw SaaS.

Wat betekent dit voor jouw project?

Als jouw SaaS een API heeft (of als je er één wil bouwen), is een SDK de volgende stap om het product serieus aan te bieden aan andere developers of integratiepartners. Zonder SDK is je API een stel losse endpoints. Met een SDK is het een product.

De overname van Stainless suggereert dat Anthropic SDK-generatie gaat inbouwen in hun tooling. Maar je hoeft niet te wachten. Claude Code kan dit nu al prima voor je doen, en vandaag is het perfecte moment om dat in te stellen.

Hoe bouw je een TypeScript SDK voor jouw API met Claude Code?

Stap 1: Breng je API in kaart

Voordat Claude Code iets kan bouwen, wil je een duidelijke beschrijving van je endpoints. Als je al een werkende API hebt, vraag Claude Code dan eerst om die te inventariseren:

Bekijk de bestanden in /app/api en maak een overzicht van alle beschikbare endpoints: het pad, de HTTP-methode, welke parameters er verwacht worden en wat de response is. Zet dit in een bestand api-overzicht.md.

Als je nog geen API hebt maar wel een idee, kun je het ook omdraaien en Claude Code de API laten ontwerpen op basis van jouw product.

Stap 2: Genereer een TypeScript SDK

Zodra je het overzicht hebt, geef je Claude Code de opdracht om de SDK te bouwen. Gebruik deze prompt als startpunt:

Gebruik api-overzicht.md om een TypeScript SDK te bouwen in de map /sdk. De SDK moet:

• Een klasse exporteren met de naam [JouwProductNaam]Client
• Een constructor accepteren met { apiKey: string, baseUrl?: string }
• Voor elk endpoint een methode aanmaken met duidelijke TypeScript types voor parameters en responses
• Errors netten afhandelen met een eigen ApiError klasse die de statuscode en message bevat
• Fetch gebruiken als HTTP-client, geen externe dependencies

Een voorbeeld van wat je dan krijgt in /sdk/index.ts:

type ClientOptions = {
  apiKey: string;
  baseUrl?: string;
};

export class MijnSaasClient {
  private apiKey: string;
  private baseUrl: string;

  constructor(options: ClientOptions) {
    this.apiKey = options.apiKey;
    this.baseUrl = options.baseUrl ?? 'https://jouwapp.nl/api';
  }

  private async request<T>(path: string, options: RequestInit = {}): Promise<T> {
    const res = await fetch(`${this.baseUrl}${path}`, {
      ...options,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json',
        ...options.headers,
      },
    });

    if (!res.ok) {
      const body = await res.json().catch(() => ({}));
      throw new ApiError(res.status, body.message ?? 'Unknown error');
    }

    return res.json() as Promise<T>;
  }

  async getProjects(): Promise<Project[]> {
    return this.request<Project[]>('/projects');
  }

  async createProject(data: CreateProjectInput): Promise<Project> {
    return this.request<Project>('/projects', {
      method: 'POST',
      body: JSON.stringify(data),
    });
  }
}

export class ApiError extends Error {
  constructor(public statusCode: number, message: string) {
    super(message);
    this.name = 'ApiError';
  }
}

Stap 3: Voeg automatische types toe op basis van je database

Als je Supabase gebruikt, kun je de types rechtstreeks uit je schema laten genereren en hergebruiken in de SDK:

npx supabase gen types typescript --project-id jouw-project-id > sdk/database.types.ts

Vraag Claude Code daarna:

Gebruik de types uit sdk/database.types.ts om de SDK-methodes in sdk/index.ts te voorzien van correcte TypeScript types. Vervang generieke types als any of handmatig geschreven interfaces door de gegenereerde Supabase-types waar dat van toepassing is.

Stap 4: Schrijf een README voor de SDK

Een SDK zonder documentatie is alsnog onbruikbaar. Laat Claude Code ook dit doen:

Schrijf een sdk/README.md met:

• Installatie-instructies (ervan uitgaande dat de SDK later als npm-pakket gepubliceerd wordt)
• Een quickstart-voorbeeld van 10 tot 15 regels
• Een overzicht van alle beschikbare methodes met parameters en return-types
• Uitleg over foutafhandeling met een concreet voorbeeld van try/catch met ApiError

Wat te checken na afloop

• Importeer de SDK in een losse test.ts en roep een methode aan. Krijg je een correcte response terug?
• Typ bewust een verkeerde parameter: geeft TypeScript een foutmelding in je editor?
• Stuur een request met een ongeldige API key: wordt de ApiError netjes gegooid met een leesbare message?
• Staat er een export in sdk/index.ts voor elke method en type die je nodig hebt?

Als je dat allemaal kunt bevestigen, heb je iets nuttigs gebouwd: een SDK die je zelf kunt gebruiken in je frontend, kunt delen met early adopters, of kunt publiceren op npm als je product groeit.