thoughtbot/guides

Features

• Guide Architectures - Implements a structured architecture for organizing language-specific stylistic guidelines and engineering best practices.
• Coding Standards - Provides shared rules for naming, formatting, and organizing code to ensure consistency across the codebase.
• Engineering Best Practices - Offers a curated collection of industry-standard architectural patterns and software engineering practices.
• Software Engineering Best Practices - Offers a comprehensive collection of professional coding standards, project structures, and version control workflows.
• Software Engineering Standards - Provides a comprehensive collection of coding styles and architectural patterns across multiple languages.
• Data Schema Management - Offers guidelines for defining and managing relational schemas, including temporal column naming conventions.
• Database Migrations - Provides standards for versioning and applying schema changes while maintaining data integrity.
• Database Naming Conventions - Defines standardized naming and indexing patterns for SQL schemas.
• Domain Logic Patterns - Defines architectural patterns for organizing business logic and associations within the model layer.
• Accessibility Automation Tools - Integrates automated accessibility auditing tools into development and CI/CD workflows to detect interface issues.
• Code Review Practices - Provides structured checklists for auditing data integrity and SQL injection risks during technical code reviews.
• Code Quality and Review - Defines systematic processes and standards for validating code integrity and style through peer review.
• Style Guides - Enforces code consistency and readability by adhering to the official Python style guide.
• Ruby Style Enforcement - Defines Ruby naming conventions, syntax rules, and architectural patterns for maintainable code.
• Swift Linting Standards - Enforces consistent naming, formatting, and architectural patterns within Swift projects.
• Version Control Workflows - Specifies a version control workflow using rebasing and squashing to maintain a clean, linear project history.
• Deployment Pipelines - Establishes a deployment workflow involving continuous integration, staging servers, and peer reviews.
• Commit History Management - Provides standards for squashing trivial commits and rewriting messages to communicate intent clearly.
• Web Deployment Pipelines - Specifies preferred tools and pipelines for server-side rendering and continuous integration in web development.
• Language-Specific Quality Standards - Implements specific quality standards and naming conventions for maintaining a predictable JavaScript codebase.
• Ruby Code Standardization - Provides a curated set of stylistic and structural rules for writing maintainable Ruby code.
• Secure Development Workflows - Establishes secure protocols for managing sensitive credentials and reporting security vulnerabilities.
• Security Vulnerability Reporting - Provides a structured process for receiving, confirming, and logging security vulnerability reports.
• Automated Quality Workflows - Defines automated workflows that integrate linting, security audits, and style checks into the development lifecycle.
• Code Style Guides - Provides a curated collection of architectural patterns and coding standards for high-quality software.
• Development Best Practices - Provides curated conventions for component structure, state, and types to ensure long-term scalability.
• Coding Standards - Establishes consistent visual styling and automated linting rules to ensure readable code and clean version control diffs.
• Naming Conventions - Establishes standardized naming conventions for RESTful routes, database schemas, and controller logic.
• Architectural Structuring - Provides a standardized directory structure for separating initializers, library code, and background jobs.
• Multi-Platform Standards - Establishes consistent architectural preferences and type safety patterns across native iOS, Android, and web platforms.
• Merge Request Workflows - Defines a collaborative workflow using feature branches and pull requests for managing code changes.
• Schema Design Standards - Provides formal principles and naming conventions for creating maintainable database schemas.
• SQL Schema Conventions - Establishes naming conventions and indexing strategies for SQL schemas to ensure data integrity.
• Object Oriented Design - Offers heuristics for managing object dependencies, method size, and class responsibilities to reduce complexity.
• Web Accessibility Standards - Provides a framework of design tokens and semantic HTML patterns following ARIA and WCAG standards.
• Inclusive Design Standards - Implements inclusive design by respecting reduced-motion preferences and providing screen-reader utilities.
• Accessibility Auditing - Implements processes for verifying semantic HTML and interface accessibility compliance using user flow analysis.
• Manual Testing Procedures - Specifies manual testing procedures using screen readers and assistive technologies to verify interface usability.
• Test Strategy Design - Defines a layered test strategy that balances unit, system, and acceptance tests for isolated verification.
• Quality Assurance Practices - Defines the use of linting, pre-commit hooks, and structured testing for quality assurance.
• Accessible UI Frameworks - Provides a framework for building inclusive web interfaces using design tokens and ARIA-compliant markup.
• Accessible Content Structuring - Implements semantic HTML markup and structural heading hierarchies to ensure content accessibility.
• Semantic Markup Standards - Provides guidelines for using semantic HTML and ARIA roles to ensure interfaces are navigable via assistive technologies.
• Web Accessibility Compliance - Implements inclusive interfaces using semantic HTML and ARIA roles based on WCAG standards.
• Frontend Performance Optimization - Provides detailed techniques for improving page load speeds and rendering stability.
• Development Workflows - Defines the full process for declaring dependencies, testing multiple versions, and releasing Ruby gems.
• Data Integrity Constraints - Establishes rules for using not-null constraints and explicit ordering to maintain data integrity.
• Database Indexing - Recommends efficient search strategies using partial and compound indexes to improve performance.
• Database Performance Optimizers - Provides patterns for enhancing relational database efficiency through strategic indexing and retrieval.
• SQL Schema Formatting - Defines conventions for organizing database columns and applying consistent casing in SQL schemas.
• Query Optimizations - Implements techniques like foreign key indexing and selective column retrieval to optimize query speed.
• Relationship Modeling - Standardizes the declaration and ordering of data associations to maintain readable domain logic.
• Result Ordering and Limiting - Defines standards for applying explicit sorting clauses to ensure consistent query result ordering.
• View Template Organization - Establishes patterns for using partials and variable passing to decouple UI logic from business models.
• Pre-commit Hooks - Automates the execution of linters and audits on staged files via pre-commit hooks.
• Shell Script Optimizers - Offers patterns for improving the performance and efficiency of shell scripts using built-in operators.
• Shell Scripting Best Practices - Establishes consistent formatting and naming conventions for shell scripts to ensure cross-shell compatibility.
• Automated Deployment Pipelines - Streamlines the build and submission process to app stores through automated deployment pipelines.
• Dependency Management - Establishes standards for versioning Ruby gems and managing environment requirements.
• Dependency Versioning - Defines strategies for versioning gem dependencies and testing against multiple environments.
• Mobile Application Development - Provides standards and best practices for building, testing, and deploying cross-platform mobile applications.
• Tech Stack Guides - Offers recommended tech stacks across web, mobile, and data-driven applications to ensure engineering consistency.
• Mobile Development - Defines strategies for selecting languages, tools, and architecture patterns for native or cross-platform mobile apps.
• Android Development - Provides coding conventions and architectural preferences for Kotlin-based Android application development.
• Coding Standards - Establishes preferred languages, architecture patterns, and accessibility requirements for native mobile development.
• Cross-Platform Application Development - Provides architectural standards for developing applications that target multiple mobile operating systems from a shared codebase.
• Store Deployment - Guides the final submission process to the app store, including regulatory and encryption reporting.
• Mobile App Routers - Defines patterns for coordinating transitions between different application views and maintaining navigation history in mobile apps.
• Mobile Backend Infrastructure - Outlines the integration of essential server-side systems for push notifications, error reporting, and payment processing in mobile apps.
• Type Safety - Implements strict typing and interface patterns to minimize runtime errors in typed projects.
• Asynchronous Task Processing - Provides architectural patterns for managing background tasks and data streams to maintain system responsiveness.
• Automated Code Review Tools - Utilizes linting tools to automatically flag style guide violations during pull request reviews.
• Backend Logic Controllers - Establishes rules for method visibility and object instantiation to keep backend controller logic lean.
• Contribution Workflows - Provides standardized processes for managing and integrating external contributions to the project codebase.
• CSS Architecture Patterns - Defines directory structures and naming conventions for maintaining large-scale, consistent CSS codebases.
• Open Source Methodologies - Provides standards and principles for the development and maintenance of open source software projects.
• Open Source Projects - Defines standardized protocols for releasing and maintaining software projects shared with the community.
• RESTful API Designs - Defines resource routing and naming conventions for predictable and clean RESTful API URLs.
• Tech Stack Recommendations - Provides guidance on selecting the optimal languages, frameworks, and libraries for server-rendered web applications.
• Static Type Checking - Implements static type checking to catch errors during development and improve editor autocomplete.
• Testing & Quality Assurance - Provides standards for layered testing strategies to ensure overall application reliability.
• Acceptance Testing - Standardizes the organization of system specs to verify end-to-end user flows.
• Automated Test Suites - Provides guidance on configuring automated test suites with custom matchers and simulation tools.
• Code Quality and Review - Defines code review standards for identifying mobile-specific pitfalls such as retain cycles and thread violations.
• CSS Linting - Enforces CSS quality and consistency through linting tools and standardized selector naming conventions.
• Test Isolation - Implements mechanisms to decouple tests using stubs, spies, and dependency injection.
• Unit Testing - Provides structural guidance for writing unit tests that verify individual components in isolation.
• Application Testing Workflows - Defines a layered testing strategy combining unit and integration tests to validate software behavior.
• Testing Best Practices - Recommends testing strategies using matchers, stubs, and spies for maintainable automated tests.
• Accessible Interface Design - Defines visual and interactive standards for creating accessible user interfaces.
• CSS Specificity Management - Implements standards for managing cascade precedence using native nesting and scope for component isolation.
• Design Tokens - Provides a system for managing reusable visual properties via CSS custom properties and semantic naming.
• Markup Formatting Standards - Defines consistent formatting and structural rules for valid and accessible HTML markup.
• Text Rendering Optimizations - Applies typography tuning, including antialiasing and ligatures, to improve visual clarity and text legibility.
• Responsive Design Patterns - Establishes architectural patterns for composing interfaces that adapt to various screen sizes.
• Responsive Layouts - Defines patterns for creating adaptive interfaces using intrinsic layouts and container queries.
• Style Selectors - Establishes rules for managing selector specificity to create maintainable and predictable stylesheets.
• Cascade Layer Management - Defines the use of explicit cascade layers to manage style priority and intentional overrides.
• Container-Scoped Isolation - Uses native CSS nesting and scoping to keep component styles isolated and prevent style leakage.
• Fluid Typography Systems - Implements responsive text scaling mechanisms that adjust smoothly based on viewport dimensions.
• Web Font Optimization - Implements font loading strategies using woff2 and swap display to reduce layout shift.
• API Design Patterns - Applies consistent HTTP design patterns and testing strategies to create maintainable JSON APIs.
• API Routing - Implements predictable naming patterns to map incoming URLs to specific controllers for consistent API structure.
• Browser Compatibility & Utilities - Sets standards for targeting baseline feature support across major web browsers.
• Schema Best Practices - Implements standardized error handling and mutation response patterns for consistent GraphQL API behavior.
• Page Speed Optimizations - Offers strategies to boost page download and rendering speed for a more responsive experience.
• Initial Page Load Optimizations - Provides techniques for optimizing initial page load times and reducing time-to-interactive for web applications.
• Pre-push Validations - Runs security audits and package checks across specific tags before pushing code to remote repositories.
• Responsive Layout Systems - Implements adaptive interfaces using intrinsic layouts, container queries, and media queries.
• Text Readability Utilities - Ships guidelines for enhancing typography through fluid scaling and controlled line-heights to improve legibility.
• Web Performance Optimization Tools - Provides guidelines for asset loading and performance optimization to improve user experience.
• Web Standards - Implements loading strategies and encoding standards to prevent visual rendering glitches.
• Programming and Development - Best practices for professional software development and team workflows.

Star history