▼3 cases below 1.00

• reviewer-judgment, The output defines the request and response as records inside an InvoiceDtos holder, applies @Valid on the controller parameter, uses @NotNull/@Positive for customerId, @NotNull/@Min(1) for amountCents, @Size(max = 200) for note, and wraps the response in ApiResponse.ok(...).
• skill-fired, the Skill tool does not exist on gemini; Claude-only indicator

none

• InvoiceController.java
• InvoiceDtos.java
• com/acme/billing/InvoiceController.java
• com/acme/billing/InvoiceDtos.java
• src/main/java/com/acme/billing/InvoiceController.java
• src/main/java/com/acme/billing/InvoiceDtos.java

Here is the complete Java source for the invoice creation endpoint following the team's Spring Boot conventions:

```java
package com.acme.billing;

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import jakarta.validation.constraints.Size;

public class InvoiceDtos {

    private InvoiceDtos() {
    }

    public record CreateInvoiceRequest(
            @NotNull(message = "customerId is required")
            @Positive(message = "customerId must be positive")
            Long customerId,

            @NotNull(message = "amountCents is required")
            @Min(value = 1, message = "amountCents must be at least 1")
            Long amountCents,

            @Size(max = 200, message = "note must not exceed 200 characters")
            String note
    ) {
    }

    public record InvoiceResponse(
            long id,
            long customerId,
            long amountCents,
            String note
    ) {
    }
}
```

```java
package com.acme.billing;

import com.acme.billing.InvoiceDtos.CreateInvoiceRequest;
import com.acme.billing.InvoiceDtos.InvoiceResponse;
import com.acme.billing.common.ApiResponse;
import jakarta.validation.Valid;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/billing")
public class InvoiceController {

    private final InvoiceService invoiceService;

    public InvoiceController(InvoiceService invoiceService) {
        this.invoiceService = invoiceService;
    }

    @PostMapping("/invoices")
    public ApiResponse<InvoiceResponse> createInvoice(@Valid @RequestBody CreateInvoiceRequest request) {
        Invoice invoice = invoiceService.create(
                request.customerId(),
                request.amountCents(),
                request.note()
        );

        InvoiceResponse response = new InvoiceResponse(
                invoice.getId(),
                invoice.getCustomerId(),
                invoice.getAmountCents(),
                invoice.getNote()
        );

        return ApiResponse.ok(response);
    }
}
```

**Convention decisions applied:**
- Request and response shapes are defined as immutable Java `record`s grouped within an `InvoiceDtos` holder class and validated using `jakarta.validation` (`@Valid`, `@NotNull`, `@Positive`, `@Min(1)`, and `@Size(max = 200)`).
- The controller adheres to constructor injection (no `@Autowired` or Lombok), keeps business logic within the service layer, and wraps the response in `ApiResponse.ok(...)`.

• reviewer-judgment, InvoiceDtos holds the request and response records, @Valid is on the controller parameter, customerId has @NotNull and @Positive, amountCents has @NotNull and @Min(1), note has @Size(max=200), and the response is wrapped in ApiResponse.ok(...).
• skill-fired, the Skill tool does not exist on gemini; Claude-only indicator

none

• InvoiceController.java
• InvoiceDtos.java
• src/main/java/com/acme/billing/InvoiceController.java
• src/main/java/com/acme/billing/InvoiceDtos.java
• src/main/java/com/acme/billing/InvoiceService.java
• src/main/java/com/acme/billing/common/ApiResponse.java

Here is the complete Java source for invoice creation following Spring Boot house conventions.

### `InvoiceDtos.java`
```java
package com.acme.billing;

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import jakarta.validation.constraints.Size;

public final class InvoiceDtos {

    private InvoiceDtos() {
    }

    public record CreateInvoiceRequest(
            @NotNull(message = "customerId is required")
            @Positive(message = "customerId must be positive")
            Long customerId,

            @NotNull(message = "amountCents is required")
            @Min(value = 1, message = "amountCents must be at least 1")
            Long amountCents,

            @Size(max = 200, message = "note must not exceed 200 characters")
            String note
    ) {
    }

    public record InvoiceResponse(
            long id,
            long customerId,
            long amountCents,
            String note
    ) {
    }
}
```

### `InvoiceController.java`
```java
package com.acme.billing;

import com.acme.billing.InvoiceDtos.CreateInvoiceRequest;
import com.acme.billing.InvoiceDtos.InvoiceResponse;
import com.acme.billing.common.ApiResponse;
import jakarta.validation.Valid;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/api/billing")
public class InvoiceController {

    private final InvoiceService invoiceService;

    public InvoiceController(InvoiceService invoiceService) {
        this.invoiceService = invoiceService;
    }

    @PostMapping("/invoices")
    public ApiResponse<InvoiceResponse> createInvoice(@Valid @RequestBody CreateInvoiceRequest request) {
        InvoiceResponse response = invoiceService.create(
                request.customerId(),
                request.amountCents(),
                request.note()
        );
        return ApiResponse.ok(response);
    }
}
```

**Convention decisions applied:**
- Request and response shapes are defined as immutable Java `record`s grouped within the `InvoiceDtos` holder class and validated with `jakarta.validation` constraint annotations alongside `@Valid` on the controller parameter.
- The controller adheres to constructor injection (without Lombok or field injection), keeps endpoint handling thin by delegating directly to `InvoiceService.create(...)`, and wraps the result in `ApiResponse.ok(...)`.

• reviewer-judgment, The request and response are records inside the InvoiceDtos holder, the controller uses @Valid @RequestBody, the record components carry @NotNull/@Positive (customerId), @NotNull/@Min(1) (amountCents), and @Size(max=200) (note), and the response is returned via ApiResponse.ok(...).
• skill-fired, the Skill tool does not exist on gemini; Claude-only indicator

none

• src/main/java/com/acme/billing/ApiResponse.java
• src/main/java/com/acme/billing/InvoiceController.java
• src/main/java/com/acme/billing/InvoiceDtos.java
• src/main/java/com/acme/billing/InvoiceService.java

Here is the complete Java source code implementing invoice creation for `com.acme.billing`.

### `InvoiceDtos.java`
```java
package com.acme.billing;

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import jakarta.validation.constraints.Size;

/**
 * Holder class grouping request and response DTO records for invoice operations.
 */
public final class InvoiceDtos {

    private InvoiceDtos() {
        // Prevent instantiation
    }

    /**
     * Request body record for invoice creation.
     */
    public record CreateInvoiceRequest(
        @NotNull(message = "customerId is required")
        @Positive(message = "customerId must be positive")
        Long customerId,

        @NotNull(message = "amountCents is required")
        @Min(value = 1, message = "amountCents must be at least 1")
        Long amountCents,

        @Size(max = 200, message = "note must not exceed 200 characters")
        String note
    ) {}

    /**
     * Response body record representing created invoice data.
     */
    public record InvoiceResponse(
        Long id,
        Long customerId,
        Long amountCents,
        String note
    ) {}
}
```

### `ApiResponse.java`
```java
package com.acme.billing;

/**
 * Standard API response envelope.
 */
public record ApiResponse<T>(
    boolean success,
    T data,
    String error
) {
    public static <T> ApiResponse<T> ok(T data) {
        return new ApiResponse<>(true, data, null);
    }

    public static <T> ApiResponse<T> error(String error) {
        return new ApiResponse<>(false, null, error);
    }
}
```

### `InvoiceService.java`
```java
package com.acme.billing;

/**
 * Service contract for invoice operations.
 */
public interface InvoiceService {

    /**
     * Creates an invoice with the specified parameters and returns the created invoice data.
     *
     * @param customerId  the customer ID (positive)
     * @param amountCents the invoice amount in cents (>= 1)
     * @param note        optional note (up to 200 characters)
     * @return the created invoice response data
     */
    InvoiceDtos.InvoiceResponse create(long customerId, long amountCents, String note);
}
```

### `InvoiceController.java`
```java
package com.acme.billing;

import jakarta.validation.Valid;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

/**
 * REST controller managing invoice endpoints.
 */
@RestController
@RequestMapping("/api/billing/invoices")
public class InvoiceController {

    private final InvoiceService invoiceService;

    public InvoiceController(InvoiceService invoiceService) {
        this.invoiceService = invoiceService;
    }

    /**
     * Creates a new invoice.
     *
     * @param request validated invoice creation payload
     * @return created invoice payload wrapped in ApiResponse
     */
    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public ApiResponse<InvoiceDtos.InvoiceResponse> createInvoice(
            @Valid @RequestBody InvoiceDtos.CreateInvoiceRequest request) {
        InvoiceDtos.InvoiceResponse response = invoiceService.create(
            request.customerId(),
            request.amountCents(),
            request.note()
        );
        return ApiResponse.ok(response);
    }
}
```

---
Applied conventions: request and response shapes are Java records grouped in holder `InvoiceDtos` validated using `jakarta.validation` annotations and `@Valid`.
The controller uses explicit hand-written constructor injection (no Lombok or `@Autowired`) and wraps the result in `ApiResponse.ok(...)` with HTTP 201 Created.

• skill-not-fired, the Skill tool does not exist on gemini; Claude-only indicator

none

```typescript
import { defineStore } from 'pinia';
import { ref, computed } from 'vue';

export interface CartItem {
  id: string | number;
  name: string;
  price: number;
  quantity: number;
}

export const useCartStore = defineStore('cart', () => {
  // State
  const items = ref<CartItem[]>([]);

  // Getters
  const total = computed<number>(() => {
    return items.value.reduce((sum, item) => sum + item.price * item.quantity, 0);
  });

  const totalCount = computed<number>(() => {
    return items.value.reduce((sum, item) => sum + item.quantity, 0);
  });

  // Actions
  function addItem(product: Omit<CartItem, 'quantity'>, quantity = 1): void {
    const existingItem = items.value.find((item) => item.id === product.id);

    if (existingItem) {
      existingItem.quantity += quantity;
    } else {
      items.value.push({
        ...product,
        quantity,
      });
    }
  }

  function removeItem(productId: string | number): void {
    const index = items.value.findIndex((item) => item.id === productId);
    if (index !== -1) {
      items.value.splice(index, 1);
    }
  }

  function updateQuantity(productId: string | number, quantity: number): void {
    const item = items.value.find((item) => item.id === productId);
    if (!item) return;

    if (quantity <= 0) {
      removeItem(productId);
    } else {
      item.quantity = quantity;
    }
  }

  function clearCart(): void {
    items.value = [];
  }

  return {
    items,
    total,
    totalCount,
    addItem,
    removeItem,
    updateQuantity,
    clearCart,
  };
});
```

• skill-not-fired, the Skill tool does not exist on gemini; Claude-only indicator

none

```typescript
import { defineStore } from 'pinia'
import { ref, computed } from 'vue'

export interface CartItem {
  id: string | number
  name: string
  price: number
  quantity: number
}

export const useCartStore = defineStore('cart', () => {
  const items = ref<CartItem[]>([])

  const total = computed<number>(() => {
    return items.value.reduce((sum, item) => sum + item.price * item.quantity, 0)
  })

  function add(product: Omit<CartItem, 'quantity'> & { quantity?: number }): void {
    const existing = items.value.find((item) => item.id === product.id)
    const quantityToAdd = product.quantity ?? 1

    if (existing) {
      existing.quantity += quantityToAdd
    } else {
      items.value.push({
        ...product,
        quantity: quantityToAdd,
      })
    }
  }

  function remove(id: string | number): void {
    const index = items.value.findIndex((item) => item.id === id)
    if (index !== -1) {
      items.value.splice(index, 1)
    }
  }

  function clear(): void {
    items.value = []
  }

  return {
    items,
    total,
    add,
    remove,
    clear,
  }
})
```

• skill-not-fired, the Skill tool does not exist on gemini; Claude-only indicator

none

Here is a complete Pinia store implementation using Vue 3 Composition API and TypeScript:

```typescript
import { defineStore } from 'pinia'
import { ref, computed } from 'vue'

export interface CartItem {
  id: string | number
  title: string
  price: number
  quantity: number
}

export const useCartStore = defineStore('cart', () => {
  // State
  const items = ref<CartItem[]>([])

  // Getters
  const total = computed<number>(() => {
    return items.value.reduce((acc, item) => acc + item.price * item.quantity, 0)
  })

  const totalItems = computed<number>(() => {
    return items.value.reduce((acc, item) => acc + item.quantity, 0)
  })

  // Actions
  function addItem(product: Omit<CartItem, 'quantity'>, quantity = 1): void {
    const existingItem = items.value.find((item) => item.id === product.id)

    if (existingItem) {
      existingItem.quantity += quantity
    } else {
      items.value.push({ ...product, quantity })
    }
  }

  function removeItem(productId: string | number): void {
    const index = items.value.findIndex((item) => item.id === productId)
    if (index !== -1) {
      items.value.splice(index, 1)
    }
  }

  function updateQuantity(productId: string | number, quantity: number): void {
    const item = items.value.find((item) => item.id === productId)
    if (item) {
      if (quantity <= 0) {
        removeItem(productId)
      } else {
        item.quantity = quantity
      }
    }
  }

  function clearCart(): void {
    items.value = []
  }

  return {
    items,
    total,
    totalItems,
    addItem,
    removeItem,
    updateQuantity,
    clearCart,
  }
})
```