Bun AI Backend Development Standards

Corporate backend microservices development environment with strict quality enforcement and measurable guarantees.

Overview

This skill provides comprehensive development standards for building production-grade backend services using Bun runtime, TypeScript, and Elysia framework. It enforces Testing Trophy methodology, strict quality gates, and enterprise health check patterns.

What This Skill Does

Enforces corporate development standards for Bun/TypeScript backends

Implements Testing Trophy test distribution (45-50% integration, 25-30% unit, 10-15% contract/e2e)

Maintains 80% minimum code coverage with automated enforcement

Provides standardized health and readiness endpoints

Ensures zero TypeScript errors with strict mode

Enforces security scanning and code quality gates

Instructions for AI Agent

When working on a Bun backend project following this standard, you MUST:

1. Core Development Standards

**Type Checking:**

Run `bun run type-check` before committing

Ensure zero TypeScript errors in strict mode

Use comprehensive type annotations

Enable all strict flags in `tsconfig.json`

**Linting:**

Run `bun run lint` to check code quality

Use `bun run lint:fix` to auto-fix issues

Address all ESLint security plugin warnings

Never bypass security rules

**Formatting:**

Run `bun run format` before committing

Use `bun run format:check` in CI/CD

Follow Prettier config: 100 char width, single quotes, trailing commas, 2-space indent

2. Testing Trophy Methodology

**Test Distribution Requirements:**

45-50% integration tests (`tests/integration/`)

25-30% unit tests (`tests/unit/`)

10-15% contract tests (`tests/contract/`)

10-15% end-to-end tests (`tests/e2e/`)

**Testing Commands:**

```bash

bun run test # Run all tests

bun run test:unit # Unit tests only

bun run test:integration # Integration tests only

bun run test:contract # Contract tests only

bun run test:e2e # End-to-end tests only

bun run test:coverage # Run with coverage report (80% minimum)

bun run test:watch # Watch mode for development

```

**Testing Philosophy:**

Write tests. Not too many. Mostly integration.

Focus on multi-component interactions over isolated units

Test real behavior, not implementation details

Maintain 80% minimum branch and line coverage

3. Project Structure

```

project/

├── src/

│ └── index.ts # Main application entry point

├── tests/

│ ├── unit/ # Unit test examples (25-30%)

│ ├── integration/ # Integration test examples (45-50%)

│ ├── contract/ # Contract test examples (10-15%)

│ ├── e2e/ # E2E test examples (10-15%)

│ └── test-utils.ts # Minimal test utilities

├── .claude/ # Claude Code hooks

├── .husky/ # Git hooks (NEVER bypass)

├── package.json # Dependencies and scripts

├── tsconfig.json # TypeScript strict config

├── eslint.config.js # ESLint flat config v9+

├── .prettierrc # Prettier config

└── bunfig.toml # Bun configuration

```

4. Health Check Implementation

**Always implement these standardized endpoints:**

**Health Endpoint (`GET /health`):**

```typescript

{

"status": "ok" | "degraded" | "unhealthy",

"timestamp": "ISO8601",

"uptime": number,

"environment": string,

"version": string

}

```

**Readiness Endpoint (`GET /ready`):**

```typescript

{

"status": "ready" | "not_ready",

"timestamp": "ISO8601",

"latency": number,

"dependencies": {

"database": {

"status": "healthy" | "unhealthy",

"latency": number,

"last_checked": "ISO8601",

"endpoint": string,

"error"?: string

"email": {

"status": "healthy" | "unhealthy",

"latency": number,

"last_checked": "ISO8601",

"endpoint": string,

"error"?: string

}

```

5. Quality Gates (STRICT ENFORCEMENT)

**Pre-commit Requirements:**

✅ TypeScript compilation passes (zero errors)

✅ ESLint validation passes (zero security violations)

✅ Prettier formatting applied

✅ All tests pass

✅ 80% minimum code coverage maintained

**⚠️ CRITICAL:** NEVER use `git commit --no-verify` or bypass pre-commit hooks. This is tracked and prohibited.

6. Available Commands Reference

**Development:**

`bun run start:dev` - Hot reload development server

`bun run start` - Production server

`bun run build` - Production build

**Code Quality:**

`bun run type-check` - TypeScript validation

`bun run lint` - Code quality checks

`bun run lint:fix` - Auto-fix issues

`bun run format` - Apply formatting

`bun run format:check` - Validate formatting

**Maintenance:**

`bun run clean` - Clean build artifacts

`bun run prepare` - Setup Husky hooks

7. Technology Stack

**Runtime:** Bun (ESNext, fast bundler, native test runner)

**Language:** TypeScript 5.6+ (strict mode)

**Framework:** Elysia (Bun-optimized, type-safe)

**Linter:** ESLint v9 (flat config)

**Formatter:** Prettier

**Test Runner:** Bun Test (native, with coverage)

**Git Hooks:** Husky v9

8. Service Standards

When building services, ensure:

Structured logging with correlation IDs

Health checks with standardized responses

Readiness checks with dependency monitoring

Configuration validation at startup

Graceful shutdown procedures

Performance monitoring integration

9. Documentation Structure

Maintain three-tier documentation:

**@concepts/README.md** - Domain models, system principles, business workflows

**@adr/README.md** - Architecture Decision Records with context and rationale

**@tasks/README.md** - Implementation-focused task documentation with phases

Workflow Example

1. **Starting a new feature:**

```bash

bun run start:dev

bun run test:watch # In separate terminal

```

2. **Writing code:**

- Implement feature in `src/`

- Add tests following Testing Trophy distribution

- Run `bun run type-check` frequently

3. **Before committing:**

```bash

bun run lint:fix

bun run format

bun run test:coverage # Must show ≥80%

bun run type-check

git commit -m "feat: add feature" # Hooks run automatically

```

4. **If hooks fail:**

- Fix the reported issues

- DO NOT use `--no-verify`

- Re-run quality checks until they pass

Constraints

Minimum 80% test coverage (branch and line) - enforced

Zero TypeScript compilation errors - enforced

Zero ESLint security violations - enforced

Prettier compliance - enforced

Testing Trophy distribution must be followed

Pre-commit hooks CANNOT be bypassed

Health and readiness endpoints are mandatory

Important Notes

This is a corporate environment with strict quality enforcement

All commits are monitored for quality gate compliance

Bypassing quality checks results in disciplinary action

Focus on integration tests per Testing Trophy methodology

Use Bun-native tools (test runner, bundler) for performance

TypeScript strict mode is non-negotiable

Bun AI Backend Development Standards

Bun AI Backend Development Standards

Overview

What This Skill Does

Instructions for AI Agent

1. Core Development Standards

2. Testing Trophy Methodology

3. Project Structure

4. Health Check Implementation

5. Quality Gates (STRICT ENFORCEMENT)

6. Available Commands Reference

7. Technology Stack

8. Service Standards

9. Documentation Structure

Workflow Example

Constraints

Important Notes

Reviews (0)