Architecture Expert | Bootspring Docs

The Architecture Expert agent specializes in software architecture, system design, code organization, design patterns, and building scalable, maintainable applications.

Expertise Areas#

Next.js App Router Structure - Route groups, layouts, loading states
Feature-Based Architecture - Organizing code by domain features
Service Layer Pattern - Business logic separation and encapsulation
Repository Pattern - Data access abstraction
Dependency Injection - Loosely coupled, testable code
Event-Driven Architecture - Decoupled system communication
Clean Architecture Layers - Separation of concerns
Error Handling Strategy - Consistent error management

Usage Examples#

App Router Structure#

Use the architecture-expert agent to design a Next.js App Router structure for a SaaS application with:
- Marketing pages
- Dashboard with sidebar
- Settings with nested routes
- API routes with webhooks

Response includes:

Complete folder structure
Route group organization
Layout component hierarchy
API route patterns

Feature-Based Architecture#

Use the architecture-expert agent to organize a React application using feature-based architecture.

Response includes:

Feature folder structure
Component organization
Hooks and actions placement
Type definitions

Service Layer#

Use the architecture-expert agent to implement a service layer pattern for a project management system.

Response includes:

Service class structure
Repository integration
Error handling
Transaction management

Best Practices Applied#

1. Clean Architecture#

Inner layers don't depend on outer layers
Dependencies flow inward
Domain layer has no external dependencies

2. Separation of Concerns#

Business logic in services
Database access through repositories
Presentation in components
Validation in dedicated schemas

3. Scalability#

Feature-based organization
Modular code structure
Clear dependency management
Environment configuration

4. Maintainability#

Consistent naming conventions
Type safety throughout
Comprehensive error handling
Logging and monitoring

Common Patterns#

Service Layer Pattern#

// services/project-service.ts
import { prisma } from '@/lib/db';
import { CreateProjectInput, UpdateProjectInput } from '@/types';
import { NotFoundError, UnauthorizedError } from '@/lib/errors';

export class ProjectService {
  async getAll(userId: string) {
    return prisma.project.findMany({
      where: {
        OR: [
          { ownerId: userId },
          { members: { some: { userId } } },
        ],
      },
      include: {
        owner: { select: { id: true, name: true, avatar: true } },
        _count: { select: { tasks: true, members: true } },
      },
      orderBy: { updatedAt: 'desc' },
    });
  }

  async create(data: CreateProjectInput, userId: string) {
    return prisma.project.create({
      data: {
        ...data,
        ownerId: userId,
        members: {
          create: { userId, role: 'owner' },
        },
      },
    });
  }
}

Repository Pattern#

// repositories/base-repository.ts
import { PrismaClient } from '@prisma/client';

export abstract class BaseRepository<T> {
  constructor(protected prisma: PrismaClient) {}

  abstract findById(id: string): Promise<T | null>;
  abstract findAll(): Promise<T[]>;
  abstract create(data: Partial<T>): Promise<T>;
  abstract update(id: string, data: Partial<T>): Promise<T>;
  abstract delete(id: string): Promise<void>;
}

Error Handling#

// lib/errors.ts
export class AppError extends Error {
  constructor(
    message: string,
    public code: string,
    public statusCode: number = 400,
    public isOperational: boolean = true
  ) {
    super(message);
    Error.captureStackTrace(this, this.constructor);
  }
}

export class NotFoundError extends AppError {
  constructor(resource: string) {
    super(`${resource} not found`, 'NOT_FOUND', 404);
  }
}

export class UnauthorizedError extends AppError {
  constructor(message = 'Unauthorized') {
    super(message, 'UNAUTHORIZED', 401);
  }
}

Sample Prompts#

Task	Prompt
Project structure	"Design a folder structure for a Next.js SaaS application"
Service layer	"Implement a service layer for user management"
Feature organization	"Organize authentication as a feature module"
Error handling	"Create a comprehensive error handling strategy"
Dependency injection	"Set up a dependency injection container"

Configuration#

// bootspring.config.js
module.exports = {
  agents: {
    customInstructions: {
      'architecture-expert': `
        - Use Next.js App Router conventions
        - Follow clean architecture principles
        - Implement service layer pattern
        - Include proper error handling
        - Design for scalability
      `,
    },
  },
  stack: {
    framework: 'nextjs',
    patterns: ['service-layer', 'repository'],
  },
};

Backend Expert - API implementation
Database Expert - Data layer design
Software Architect - System-level design