universal-dev-standards

🥈Silver

Universal, language-agnostic development standards for software projects. Includes coding standards, git workflows, testing guidelines, documentation structure, and AI collaboration rules. Benefits developers, engineering managers, and DevOps teams by ensuring consistency and quality across projects. Integrates with git, CI/CD pipelines, and developer tools.

5940Updated 2mo ago

Intermediate30min to implementautomation

Saves ~180 min per use

Quick InstallView Source

git clone https://github.com/AsiaOstrich/universal-dev-standards.git

Works with:

Claude

Overview

About This Skill

The Universal Dev Standards skill is designed to establish a cohesive framework for software development across various programming languages. By providing language-agnostic coding standards, git workflows, testing guidelines, documentation structures, and AI collaboration rules, this skill ensures that teams can maintain consistency and quality in their projects. It is particularly beneficial for teams looking to standardize their development processes, making it easier to onboard new members and collaborate effectively. One of the key benefits of implementing Universal Dev Standards is the potential for significant time savings in project setup and maintenance. By adhering to established guidelines, teams can reduce the time spent on code reviews and debugging, as well as streamline the onboarding process for new developers. Although the exact time savings are not quantified, the efficiency gained from a standardized approach can lead to faster project delivery and improved team productivity. This skill is ideal for developers, product managers, and AI practitioners who are involved in software projects. It is particularly relevant for teams working in environments where multiple programming languages are used, as it provides a unified set of standards that can be applied regardless of the technology stack. For example, a team developing a web application using both frontend and backend technologies can benefit from consistent documentation and testing practices, leading to a smoother development cycle. With an intermediate level of complexity, the Universal Dev Standards skill can be implemented in approximately 30 minutes, making it accessible for teams looking to enhance their workflows quickly. As organizations increasingly adopt AI-first strategies, this skill fits seamlessly into AI-driven workflows by establishing clear guidelines for AI collaboration. By integrating these standards, teams can leverage AI tools more effectively, ensuring that their development practices align with modern automation needs.

How to Use

1. **Customize the Prompt:** Replace [LANGUAGE], [PROJECT_NAME], [TEAM_SIZE], and [PROJECT_COMPLEXITY] with your project details. For example: `[LANGUAGE] = JavaScript`, `[PROJECT_NAME] = Dashboard Analytics`, `[TEAM_SIZE] = 5`, `[PROJECT_COMPLEXITY] = medium`. 2. **Generate the Standards:** Paste the customized prompt into your AI tool (e.g., Claude, ChatGPT) and run it. Save the output as `dev-standards.md` in your project root. 3. **Integrate with Tools:** - For **coding standards**, add `black` (Python) or `Prettier` (JavaScript) to your pre-commit hooks. - For **Git workflow**, set up branch protection rules in GitHub/GitLab and configure CI to enforce standards. - For **testing**, add `pytest-cov` to measure coverage and fail builds below 80%. 4. **Train the Team:** Share the document in your team’s wiki (e.g., Confluence, Notion) and hold a 30-minute workshop to review key sections like Git workflow and AI collaboration rules. 5. **Iterate:** Schedule a quarterly review to update standards based on feedback or new tooling (e.g., if your team adopts a new linter).

Setup & Installation

Quick Install

No install command available. Check the GitHub repository for manual installation instructions.

Alternative Install (Git Clone)

git clone https://github.com/AsiaOstrich/universal-dev-standards

Requirements

Claude Code or compatible AI agent
Works with: Claude

Quick Start Guide

Install the Skill

Copy the install command above and run it in your terminal.

Open Your AI Agent

Launch Claude Code, Cursor, or your preferred AI coding agent.

Try It Out

Use the prompt template or examples below to test the skill.

Customize

Adapt the skill to your specific use case and workflow.

Usage Examples

Prompt Template

Generate a universal development standards document for a [LANGUAGE] project named [PROJECT_NAME]. Include sections for: 1) Coding standards (e.g., naming conventions, formatting rules), 2) Git workflow (branching strategy, commit messages, PR guidelines), 3) Testing guidelines (unit, integration, E2E), 4) Documentation structure (README, API docs, architecture decisions), and 5) AI collaboration rules (how to use AI tools like GitHub Copilot, code review assistance). Use [TEAM_SIZE] as the team size and [PROJECT_COMPLEXITY] (low/medium/high).

Example Output

### Universal Development Standards for Project: **E-Commerce Platform**

#### 1. Coding Standards
**Language:** Python 3.11
- **Naming Conventions:** Use snake_case for variables/functions, PascalCase for classes. Example: `def calculate_total_price()` not `def CalculateTotalPrice()`.
- **Formatting:** Follow PEP 8 with 120-character line limits. Use `black` for auto-formatting in CI.
- **Imports:** Group imports by standard library, third-party, and local. Example:
  ```python
  import os
  import sys
  
  import requests
  from flask import Flask
  
  from app.utils import helper
  ```

#### 2. Git Workflow
**Branching Strategy:** GitHub Flow with protected `main` branch.
- **Branches:** Feature branches prefixed with `feature/`, e.g., `feature/payment-gateway`.
- **Commits:** Use Conventional Commits (e.g., `feat(payment): add Stripe integration`).
- **Pull Requests:** Require 2 approvals, link to Jira ticket, and pass CI checks.

#### 3. Testing Guidelines
**Coverage:** Minimum 80% unit test coverage for core modules.
- **Unit Tests:** Use `pytest` with fixtures for dependencies. Example:
  ```python
  def test_calculate_discount():
      assert calculate_discount(100, 20) == 80
  ```
- **Integration Tests:** Test API endpoints with `pytest` and `FastAPI TestClient`.
- **E2E Tests:** Use Playwright for user flows (e.g., checkout process).

#### 4. Documentation Structure
- **README.md:** Project overview, setup instructions, and architecture diagram.
- **API Docs:** Auto-generated with Swagger/OpenAPI. Example endpoint:
  ```
  GET /api/v1/products/{id} -> Returns product details.
  ```
- **ADRs:** Architecture Decision Records in `/docs/adr/` (e.g., `adr-001-use-postgres.md`).

#### 5. AI Collaboration Rules
- **GitHub Copilot:** Use for boilerplate code (e.g., FastAPI endpoints) but manually review suggestions.
- **Code Review:** AI tools (e.g., CodeClimate) flag style issues; human review required for logic.
- **Documentation:** Use AI to draft ADRs or READMEs, but validate with team leads.

**Team Size:** 8 developers
**Project Complexity:** High (microservices, payment integration)