write-integration

Create external integrations following the Epic three-layer architecture.

Updated Oct 29, 2025
One-click install
npx skills add https://github.com/coeus-ventures/epic-web --skill write-integration
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: write-integration
Source: https://github.com/coeus-ventures/epic-web/tree/main/.claude/skills/write-integration
Command: npx skills add https://github.com/coeus-ventures/epic-web --skill write-integration

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

External integrations following the Epic architecture pattern enable teams to build reusable, server-side connectors to third-party APIs, services, and backend systems with clear boundaries.

Core Features & Use Cases

  • Run on the server to isolate external calls from frontend concerns
  • Implement reusable integration services for Stripe, GitHub, email, and payments
  • Enforce the Epic three-layer architecture to decouple infrastructure and external dependencies

Quick Start

Define a new integration following the Epic three-layer structure under shared/integrations.

Frequently Asked Questions about write-integration

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
What is the Epic three-layer architecture for external integrations?

The Epic three-layer architecture is a structural pattern for building reusable, server-side connectors to third-party APIs. It decouples infrastructure and external dependencies by enforcing strict boundaries, isolating external calls from frontend concerns.

How do I structure a backend service to integrate with external APIs?

Structure external API integrations by defining a new service under a shared integrations directory. Follow the Epic three-layer architecture to enforce server-side execution, strong typing, and standardized exports for secure, decoupled backend connections.

Can I use this pattern to build integration services for payments and messaging?

Yes, this pattern applies to building reusable integration services for payment and messaging workflows. It supports connecting to external providers like Stripe, GitHub, and email by enforcing server-side execution and standardized error handling.

Why isolate external API calls on the server instead of the frontend?

Isolating external API calls on the server secures your integration by keeping external dependencies and infrastructure decoupled from frontend concerns. This architecture enforces strong typing and error handling while supporting reusable backend services.

What's the best way to decouple infrastructure dependencies for third-party services?

Decouple infrastructure dependencies by applying the Epic three-layer architecture to your external integrations. This pattern enforces clear boundaries and strong typing, resulting in reusable backend services that separate external API infrastructure from your core application logic.

Does this integration pattern enforce strong typing and error handling?

Yes, this integration pattern enforces server-side execution with strong typing and standardized error handling. These constraints ensure that external API clients and backend services remain secure, reusable, and maintainable across different workflows.