New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Backend Dev

by julianromli in julianromli/opencode-template

Comprehensive backend development workflow that orchestrates expert analysis, architecture design, implementation, and deployment using the integrated toolset.

Apache-2.0Auto-check passedBackend & APIs

Install Backend Dev

skills CLI
$ npx skills add julianromli/opencode-template --skill backend-dev -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install julianromli/opencode-template backend-dev --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/julianromli/opencode-template.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skill/backend-dev .claude/skills/backend-dev && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
backend-dev
GitHub stars
144
Token cost
~4.4k tokens
SKILL.md length
1,243 words
Files
4
Skills in repo
16
Repo updated
First seen
Licence
Apache-2.0

At a glance

Comprehensive backend development workflow that orchestrates expert analysis, architecture design, implementation, and deployment using the integrated toolset.

  • Works in 6 steps: Requirements Analysis & Technical Planning → System Architecture & Design → Implementation Planning & Technology… → …
  • Tasks that involve Backend development
  • SKILL.md covers Overview, When to Use This Skill, Backend Development Expert Panel and Backend Development Workflow, plus 4 more sections
  • Calls python and playwright

What it does

Backend Dev is an agent skill from julianromli/opencode-template. Comprehensive backend development workflow that orchestrates expert analysis, architecture design, implementation, and deployment using the integrated toolset. Handles everything from API design and database architecture to security implementation and DevOps automation.

Its SKILL.md is about 4.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files (for example `README.md` and `examples.md`).

It sits in Backend & APIs, covering Backend development, API design and Deployment. The repository describes itself as: OpenCode CLI Template by @faizntfd. The licence is Apache-2.0.

When your agent uses it

  • Tasks that involve Backend development
  • Tasks that involve API design
  • Tasks that involve Deployment

Example prompts

  • “/backend-dev”

Requirements

  • Python 3
  • Node.js
  • Docker

Workflow steps

6 steps, taken from the step headings in SKILL.md.

  1. Requirements Analysis & Technical Planning
  2. System Architecture & Design
  3. Implementation Planning & Technology Selection
  4. Secure & Scalable Implementation
  5. Testing & Quality Assurance
  6. DevOps & Deployment

What it can do on your machine

Read from SKILL.md and the folder at commit 37ceab2. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • python
    • playwright

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Backend Dev loads about 4.4k tokens when it runs. Until then it costs about 71 tokens; SKILL.md has 1,243 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~71
When it runs · the whole SKILL.md, loaded when a task matches
~4.4k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from julianromli/opencode-template at commit 37ceab2, republished under its Apache-2.0 licence (© julianromli). 1,243 words, ~4,355 tokens.

Download SKILL.mdSave it as .claude/skills/backend-dev/SKILL.md (or your agent's skills folder). This skill also uses 3 other files; get the full folder from GitHub.
name
backend-dev
description
Comprehensive backend development workflow that orchestrates expert analysis, architecture design, implementation, and deployment using the integrated toolset. Handles everything from API design and database architecture to security implementation and DevOps automation.
license
Apache 2.0

Backend Development Master - Complete Backend Engineering Workflow

Overview

This skill provides end-to-end backend development services by orchestrating multiple expert systems, advanced development techniques, and specialized tools. It transforms business requirements into production-ready backend systems with comprehensive architecture, security, scalability, and operational excellence.

Key Capabilities:

  • 🏗️ Multi-Expert Backend Architecture - Coordinates backend architects, security engineers, and DevOps specialists
  • 🎯 Full-Stack Development - From API design to database architecture to deployment automation
  • 📊 Production-Ready Implementation - Security-first, scalable, and maintainable code generation
  • 🔧 DevOps Integration - CI/CD pipelines, monitoring, and infrastructure as code
  • 📋 Comprehensive Testing - Unit, integration, and end-to-end testing strategies

When to Use This Skill

Perfect for:

  • New backend system development and API creation
  • Legacy system modernization and microservice decomposition
  • Database architecture and optimization projects
  • Security implementation and compliance requirements
  • Performance optimization and scalability planning
  • DevOps pipeline and infrastructure automation

Triggers:

  • "Create a backend API for [application]"
  • "Design database architecture for [system]"
  • "Build a scalable backend service"
  • "Implement security and authentication"
  • "Set up CI/CD and deployment pipeline"

Backend Development Expert Panel

Backend Architect (System Design)
  • Focus: API design, database architecture, system scalability
  • Techniques: RESTful services, GraphQL, microservices, data modeling
  • Considerations: Performance, scalability, maintainability, API contracts
Security Engineer (Secure Development)
  • Focus: Authentication, authorization, data protection, compliance
  • Techniques: OWASP compliance, encryption, threat modeling, secure coding
  • Considerations: Security by design, zero-trust principles, regulatory compliance
DevOps Architect (Operations & Deployment)
  • Focus: CI/CD, infrastructure automation, monitoring, reliability
  • Techniques: Container orchestration, IaC, observability, zero-downtime deployment
  • Considerations: Infrastructure costs, reliability, scaling strategies, monitoring
Database Specialist (Data Architecture)
  • Focus: Schema design, query optimization, data modeling, migrations
  • Techniques: Normalization, indexing strategies, caching, data consistency
  • Considerations: Data integrity, performance, scalability, backup strategies
Performance Engineer (Optimization)
  • Focus: Performance optimization, bottleneck analysis, caching strategies
  • Techniques: Profiling, load testing, optimization patterns, scaling solutions
  • Considerations: Response times, throughput, resource utilization, cost efficiency

Backend Development Workflow

Phase 1: Requirements Analysis & Technical Planning

Use when: Starting new backend development or modernizing existing systems

Tools Used:

bash
/sc:analyze backend-requirements
BMAD PM Agent: business requirement analysis
Requirements Analyst: technical specification creation
Deep Research Agent: technology stack research

Activities:

  • Analyze business requirements and translate to technical specifications
  • Identify scalability, security, and performance requirements
  • Evaluate technology stack options and architectural patterns
  • Define API contracts and data models
  • Plan integration points and external dependencies
Phase 2: System Architecture & Design

Use when: Designing the technical architecture and system components

Tools Used:

bash
/sc:design --type architecture backend-system
/sc:design --type api restful-apis
/sc:design --type database data-model
Backend Architect: comprehensive system design
Security Engineer: security architecture planning

Activities:

  • Design system architecture and component boundaries
  • Create API specifications and data contracts
  • Design database schemas and relationships
  • Plan security architecture and authentication flows
  • Define scalability and performance strategies
Phase 3: Implementation Planning & Technology Selection

Use when: Preparing for actual code implementation

Tools Used:

bash
/sc:design --type component implementation-strategy
Python Expert: technology-specific implementation patterns
DevOps Architect: deployment and infrastructure planning
Performance Engineer: optimization and monitoring setup

Activities:

  • Select appropriate frameworks, libraries, and tools
  • Create implementation roadmap with milestones
  • Plan database migrations and data seeding strategies
  • Design error handling and logging strategies
  • Prepare development environment and tooling setup
Phase 4: Secure & Scalable Implementation

Use when: Writing production-ready backend code

Tools Used:

bash
/sc:implement backend-service
Python Expert: production-quality code implementation
Security Engineer: secure coding practices and vulnerability prevention
Database Specialist: optimized database interactions
Performance Engineer: efficient algorithms and caching strategies

Activities:

  • Implement core business logic and API endpoints
  • Create secure authentication and authorization systems
  • Optimize database queries and implement caching strategies
  • Implement comprehensive error handling and logging
  • Write unit and integration tests with high coverage
Phase 5: Testing & Quality Assurance

Use when: Ensuring system reliability and security

Tools Used:

bash
/sc:test backend-comprehensive
Quality Engineer: testing strategy implementation
Security Engineer: security testing and vulnerability scanning
Performance Engineer: load testing and performance validation
Playwright MCP: end-to-end API testing

Activities:

  • Implement comprehensive test suites (unit, integration, E2E)
  • Conduct security testing and vulnerability assessments
  • Perform load testing and performance benchmarking
  • Validate API contracts and data integrity
  • Test error scenarios and recovery mechanisms
Phase 6: DevOps & Deployment

Use when: Preparing for production deployment

Tools Used:

bash
/sc:implement production-deployment
DevOps Architect: CI/CD pipeline and infrastructure setup
Security Engineer: production security hardening
Monitoring Setup: observability and alerting systems

Activities:

  • Set up CI/CD pipelines with automated testing and deployment
  • Implement infrastructure as code and containerization
  • Configure monitoring, logging, and alerting systems
  • Create deployment strategies and rollback procedures
  • Document operations procedures and runbooks

Integration Patterns

SuperClaude Command Integration
CommandUse CaseOutput
/sc:design --type architectureSystem architectureTechnical architecture specifications
/sc:design --type apiAPI designRESTful/GraphQL API specifications
/sc:design --type databaseDatabase designOptimized schema and data models
/sc:implement backendCode implementationProduction-ready backend services
/sc:test backendTesting strategyComprehensive testing plans
/sc:build deployDeployment setupCI/CD and infrastructure automation
BMAD Method Integration
TechniqueRoleCapabilities
Greenfield Service WorkflowNew project developmentComplete backend service development
Brownfield IntegrationLegacy modernizationSafe system evolution and integration
Security-First DevelopmentSecure implementationBuilt-in security practices and validation
Performance OptimizationScalability planningBottleneck identification and optimization
MCP Server Integration
ServerExpertiseUse Case
SequentialComplex reasoningArchitecture analysis and problem-solving
Context7Technical patternsFramework best practices and implementation guides
PlaywrightAPI testingEnd-to-end API validation and testing
SerenaProject memoryLarge codebase navigation and context management

Usage Examples

Example 1: New REST API Development
User: "Create a backend API for an e-commerce platform with user management, product catalog, and order processing"

Workflow:
1. Phase 1: Analyze e-commerce requirements and technical constraints
2. Phase 2: Design microservices architecture with API contracts
3. Phase 3: Plan implementation with Node.js/Express and PostgreSQL
4. Phase 4: Implement secure APIs with JWT authentication
5. Phase 5: Test with comprehensive test suites and load testing
6. Phase 6: Deploy with Docker, Kubernetes, and CI/CD pipeline

Output: Production-ready e-commerce backend with 99.9% uptime target
Example 2: Database Architecture Optimization
User: "Optimize our database architecture for better performance and scalability"

Workflow:
1. Phase 1: Analyze current database performance and bottlenecks
2. Phase 2: Design optimized schema with proper indexing
3. Phase 3: Plan migration strategy with zero downtime
4. Phase 4: Implement caching layer and query optimization
5. Phase 5: Performance test and validate improvements
6. Phase 6: Deploy with monitoring and alerting

Output: 60% performance improvement with horizontal scaling capability
Example 3: Security Implementation
User: "Implement comprehensive security for our financial services backend"

Workflow:
1. Phase 1: Analyze security requirements and compliance needs (SOC2, PCI-DSS)
2. Phase 2: Design zero-trust security architecture
3. Phase 3: Plan secure implementation with encryption and audit logging
4. Phase 4: Implement security controls and monitoring
5. Phase 5: Conduct security testing and vulnerability assessment
6. Phase 6: Deploy with security monitoring and incident response

Output: Fully compliant financial services backend with comprehensive security

Quality Assurance Mechanisms

Show full SKILL.md (511 more words)Show less
Multi-Expert Validation
  • Cross-Domain Review: Backend architect, security, and DevOps perspectives
  • Security Validation: Comprehensive vulnerability scanning and compliance checking
  • Performance Testing: Load testing, stress testing, and optimization validation
  • Production Readiness: Complete deployment and operational validation
Automated Quality Checks
  • Code Quality: Linting, formatting, and complexity analysis
  • Security Scanning: Automated vulnerability detection and dependency checking
  • Performance Monitoring: Response time, throughput, and resource utilization tracking
  • Test Coverage: Unit, integration, and end-to-end test coverage validation
Continuous Improvement
  • Performance Monitoring: Real-time performance tracking and alerting
  • Security Monitoring: Continuous vulnerability scanning and threat detection
  • Feedback Integration: User feedback and performance data analysis
  • Pattern Learning: Successful patterns recognition and reuse

Output Deliverables

Primary Deliverable: Complete Backend System
backend-system/
├── api/
│   ├── controllers/              # API endpoint implementations
│   ├── middleware/               # Authentication, validation, error handling
│   ├── routes/                   # API routing and endpoint definitions
│   └── documentation/            # API documentation and contracts
├── services/
│   ├── business/                 # Business logic and domain services
│   ├── data/                     # Data access and database services
│   ├── external/                 # Third-party service integrations
│   └── security/                 # Security services and utilities
├── database/
│   ├── migrations/               # Database schema migrations
│   ├── seeds/                    # Initial data setup
│   ├── models/                   # Data models and relationships
│   └── queries/                  # Optimized database queries
├── tests/
│   ├── unit/                     # Unit tests for individual components
│   ├── integration/              # Integration tests for service interactions
│   ├── e2e/                      # End-to-end API tests
│   └── performance/              # Load and stress tests
├── infrastructure/
│   ├── docker/                   # Container configurations
│   ├── kubernetes/               # K8s deployment manifests
│   ├── ci-cd/                    # CI/CD pipeline configurations
│   └── monitoring/               # Logging, metrics, and alerting
├── documentation/
│   ├── architecture.md           # System architecture documentation
│   ├── api-specs.md              # API specifications and contracts
│   ├── deployment.md             # Deployment procedures and runbooks
│   └── security.md               # Security procedures and compliance
└── config/
    ├── development/              # Development environment configurations
    ├── staging/                  # Staging environment configurations
    └── production/               # Production environment configurations
Supporting Artifacts
  • Architecture Documentation: Detailed system design and technical specifications
  • API Documentation: Comprehensive API contracts and usage examples
  • Security Documentation: Security procedures, compliance reports, and audit trails
  • Performance Reports: Benchmarking results and optimization recommendations
  • Deployment Guides: Step-by-step deployment and operational procedures

Advanced Features

Intelligent Technology Selection
  • Automatically recommends appropriate technology stacks based on requirements
  • Considers team expertise, scalability needs, and maintenance requirements
  • Optimizes for cost, performance, and development efficiency
  • Supports multiple programming languages and frameworks
Security-First Development
  • Built-in security practices and vulnerability prevention
  • Automated security scanning and compliance checking
  • Comprehensive authentication and authorization patterns
  • Integration with security monitoring and threat detection
Performance Optimization
  • Proactive performance monitoring and bottleneck identification
  • Automated optimization suggestions and implementation
  • Load testing and capacity planning tools
  • Real-time performance tracking and alerting
DevOps Automation
  • Complete CI/CD pipeline setup with automated testing and deployment
  • Infrastructure as code with version control and reproducibility
  • Container orchestration and microservice deployment
  • Comprehensive monitoring, logging, and alerting systems

Troubleshooting

Common Backend Development Challenges
  • Scalability Issues: Use microservices architecture and horizontal scaling patterns
  • Security Vulnerabilities: Apply security-first development and comprehensive testing
  • Performance Bottlenecks: Implement caching strategies and database optimization
  • Database Complexity: Use proper normalization, indexing, and query optimization
Deployment and Operations Issues
  • Deployment Failures: Use blue-green deployments and automated rollback
  • Monitoring Gaps: Implement comprehensive observability and alerting
  • Integration Problems: Design clear APIs and implement proper error handling
  • Security Incidents: Implement incident response procedures and security monitoring

Best Practices

For System Design
  • Design for scalability and maintainability from the start
  • Use microservices architecture for complex systems
  • Implement proper separation of concerns and modularity
  • Design for failure with circuit breakers and graceful degradation
For Security Implementation
  • Implement security by design, not as an afterthought
  • Use zero-trust principles and defense-in-depth strategies
  • Regularly update dependencies and conduct security audits
  • Implement comprehensive logging and monitoring for security events
For Performance Optimization
  • Profile before optimizing to identify real bottlenecks
  • Implement appropriate caching strategies at multiple levels
  • Use database indexing and query optimization techniques
  • Monitor performance metrics and set up alerting
For DevOps and Deployment
  • Automate everything that can be automated
  • Use infrastructure as code for reproducible deployments
  • Implement comprehensive monitoring and observability
  • Plan for failure with backup and disaster recovery procedures

This backend development skill transforms the complex process of backend system creation into a guided, expert-supported workflow that leverages the full power of your integrated development toolset. It ensures that backend systems are secure, scalable, maintainable, and production-ready from day one.

© julianromli, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 3 other files in skill/backend-dev of julianromli/opencode-template.

  • SKILL.md
  • LICENSE.txt
  • README.md
  • examples.md

Open the folder on GitHubat commit 37ceab2

Compare with similar skills

Backend Dev next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Backend Dev compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Backend Dev this skilljulianromli/opencode-template144—~4.4kAutomated safety check: PassApache-2.0
Nodejs Backend Patternsever-works/ever-works15818 repos~4kAutomated safety check: PassAGPL-3.0
Pangolin CRUD Endpointsfosrl/pangolin23k—~461Automated safety check: PassCustom licence
Backend PatternshellangleZ/burn-in-cceverywhere-ralph11217 repos~3.3kAutomated safety check: PassNone
API Surface Reviewpolarsource/polar10k—~1.3kAutomated safety check: PassMIT
Backend FundamentalsDanielPodolsky/ownyourcode2901 repos~1.1kAutomated safety check: PassMIT

Similar skills

  • Nodejs Backend Patterns

    ever-works/ever-works

    Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices.

    158 GitHub starsUsed in 18 repos~4k tokens
    Backend & APIsAuto-check passed

  • Pangolin CRUD Endpoints

    fosrl/pangolin

    Use whenever asked to add, create, or scaffold a CRUD endpoint, router, or entity in this repo's server (create/list/get/update/delete handlers, new…

    23k GitHub stars~461 tokensUpdated today
    Backend & APIsAuto-check passed

  • Backend Patterns

    hellangleZ/burn-in-cceverywhere-ralph

    Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes.

    112 GitHub starsUsed in 17 repos~3.3k tokens
    Backend & APIsAuto-check passed

  • API Surface Review

    polarsource/polar

    Review changes to Polar's API contract — Pydantic schemas, FastAPI endpoints, OpenAPI output and the generated SDKs.

    10k GitHub stars~1.3k tokensUpdated today
    Backend & APIsAuto-check passed

  • Backend Fundamentals

    DanielPodolsky/ownyourcode

    Reviews API design, REST conventions, and backend architecture.

    290 GitHub starsUsed in 1 repo~1.1k tokens
    Backend & APIsAuto-check passed

  • API Design

    selmakcby/claude-agents-skills

    Backend API design specialist. An agent skill from selmakcby/claude-agents-skills.

    136 GitHub stars~1.1k tokensUpdated 5 mo ago
    Backend & APIsAuto-check passed

More from julianromli/opencode-template

All 16 skills in this repo

  • Using Git Worktrees

    julianromli/opencode-template

    A skill your agent uses when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory…

    144 GitHub starsUsed in 28 repos~1.4k tokens
    Auto-check passed

  • Ralph

    julianromli/opencode-template

    Autonomous agent loop for completing features. An agent skill from julianromli/opencode-template.

    144 GitHub starsUsed in 1 repo~1.1k tokens
    Auto-check passed

  • Rsc Data Optimizer

    julianromli/opencode-template

    Optimize Next.js App Router data fetching by converting slow client-side fetching to fast server-side fetching using React Server Components (RSC).

    144 GitHub starsUsed in 1 repo~805 tokens
    Auto-check passed

  • Shadcn Management

    julianromli/opencode-template

    Manage shadcn/ui components using MCP tools. An agent skill from julianromli/opencode-template.

    144 GitHub starsUsed in 1 repo~733 tokens
    Auto-check passed

  • Frontend UI Animator

    julianromli/opencode-template

    Analyze and implement purposeful UI animations for Next.js + Tailwind + React projects.

    144 GitHub stars~1.2k tokensUpdated 8 mo ago
    Auto-check passed

  • Agents Md Generator

    julianromli/opencode-template

    Generate hierarchical AGENTS.md structures for codebases. An agent skill from julianromli/opencode-template.

    144 GitHub starsUsed in 1 repo~1.4k tokens
    Auto-check: notes

Categories

Questions about Backend Dev

What does Backend Dev do?

Comprehensive backend development workflow that orchestrates expert analysis, architecture design, implementation, and deployment using the integrated toolset. Backend Dev is an agent skill from julianromli/opencode-template. Comprehensive backend development workflow that orchestrates expert analysis, architecture design, implementation, and deployment using the integrated toolset.

When should I use Backend Dev?

Backend Dev fits situations like: tasks that involve Backend development; tasks that involve API design; tasks that involve Deployment.

How do I install Backend Dev in Claude Code?

Run `npx skills add julianromli/opencode-template --skill backend-dev -a claude-code`. Or copy the skill folder (skill/backend-dev in julianromli/opencode-template) into .claude/skills/backend-dev in your project. Claude Code loads it when a task matches its description.

How do I install Backend Dev in Codex?

Run `npx skills add julianromli/opencode-template --skill backend-dev -a codex`. Or copy the skill folder (skill/backend-dev in julianromli/opencode-template) into .agents/skills/backend-dev in your project. Codex loads it when a task matches its description.

Can I use Backend Dev in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add julianromli/opencode-template --skill backend-dev -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/backend-dev, .gemini/skills/backend-dev, .github/skills/backend-dev and .opencode/skills/backend-dev in your project.

What does Backend Dev need to run?

Going by SKILL.md and its folder, Backend Dev needs the command-line tools its instructions call (python and playwright). Our summary lists: Python 3; Node.js; Docker.

Does Backend Dev access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Backend Dev safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Backend Dev use?

Backend Dev is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Backend Dev use?

About 4.4k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Backend Dev?

Skills that share tags, products or a category with Backend Dev: Nodejs Backend Patterns (ever-works/ever-works, 158 stars), Pangolin CRUD Endpoints (fosrl/pangolin, 23k stars), Backend Patterns (hellangleZ/burn-in-cceverywhere-ralph, 112 stars) and API Surface Review (polarsource/polar, 10k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Backend Dev?

julianromli (a GitHub user) maintains it in julianromli/opencode-template, which has 144 GitHub stars. The repository holds 16 skills in this directory. The repository was last updated on February 3, 2026.

Source: julianromli/opencode-template on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.