phodal/prompt-patterns
Prompt Patterns
Prompt patterns is a framework for organizing AI-driven system design through structured prompt engineering and domain-driven development methodologies. It provides a library of standardized interaction strategies designed to improve the consistency, accuracy, and logical reasoning of large language model outputs. By applying these patterns, users can translate complex business scenarios into structured domain models and technical specifications.
The project distinguishes itself by integrating domain-driven design principles directly into the prompting workflow. It utilizes techniques such as symbolic instruction encoding, declarative constraint modeling, and iterative refinement to bridge the gap between abstract business requirements and concrete technical implementation. These methods allow for the decomposition of multi-faceted tasks into manageable segments, ensuring that generated outputs remain aligned with specific architectural boundaries and system requirements.
Beyond core prompting strategies, the framework supports the generation of technical documentation, system architecture diagrams, and API specifications. It employs various structural techniques, including few-shot context injection, persona adoption, and negative constraint application, to enforce precision and reduce ambiguity during model interactions. The repository serves as a comprehensive resource for building repeatable, high-quality instruction frameworks for complex software development tasks.
Features
- Domain-Driven Prompting - Maps business domain models and system boundaries into structured prompts for architecture generation.
- Prompt Persona Definitions - The framework simulates specific entities or characters to ensure generated responses remain consistent with required styles, perspectives, and contextual expectations.
- Prompt Constraint Templates - The framework guides output by providing structural constraints, such as code snippets or function signatures, to achieve precise and predictable results.
- Behavioral Constraints - Defines operational rules and negative constraints within system prompts to guide model behavior.
- Prompt Engineering Frameworks - Provides a collection of structured design patterns and templates for crafting precise, repeatable, and logical instructions for large language models.
- Prompt Engineering Patterns - Organizes complex instructions into reusable templates that enforce consistent logic and structure.
- Prompt Engineering Workflows - Provides structured instruction frameworks to improve the consistency and quality of AI-generated outputs.
- Symbolic Instruction Encodings - Provides custom symbolic notations to simplify the communication of complex constraints and logical rules to large language models.
- Chain Of Thought - Breaks down complex, multi-faceted tasks into sequential logical steps to improve reasoning accuracy.
- Domain-Driven Designs - Translates complex business scenarios into structured entities to align software architecture with business requirements.
- Prompt Templates - Applies structured formatting rules and stylistic constraints to guide the generation of consistent technical or manual-style documentation.
- Role Simulations - Simulates specific identities or professional roles to influence the tone, context, and style of generated responses.
- Prompt Design Strategies - Structures input instructions using a consistent framework of problem, solution, and applicability to ensure predictable model outputs.
- Reasoning Chains - Decomposes complex problems into sequences of intermediate logical steps to improve accuracy in multi-step reasoning and analytical tasks.
- Task Decompositions - Breaks down large or multi-faceted requests into smaller, manageable segments to overcome context limitations and ensure high-quality results.
- Few-Shot Pattern Exemplification - Supplies representative input-output pairs to guide models toward desired formats and logic.
- Prompt Iteration - Builds system components through successive model interactions that use previous outputs as a foundation.
- Technical Documentation Generators - Applies structured templates and stylistic constraints to generate consistent technical documentation.
- System Architecture Visualizers - Maps logical processes and system components into standardized diagrams to clarify complex relationships.
- Structured Output Visualizers - Provides visual representations of generated content using diagrams and structured modeling languages.
- Domain Specific Languages - The framework employs programming languages or domain-specific schemas to provide precise, concise instructions that reduce ambiguity and token usage.
- System Architecture Models - Maps relationships between business subdomains and defines network endpoints based on established domain models.
- Concept Mapping - The framework researches and summarizes unfamiliar topics or abstract concepts to bridge knowledge gaps and improve understanding during interactions.
- Business Logic Visualizations - Uses diagrams and flowcharts to represent functional architecture and system workflows for improved AI alignment.
- Domain Model Implementations - Decomposes complex business scenarios into entities and actions to create a unified language for software implementation.
- Domain Model Analysis - Decomposes business activities into distinct scenarios and event-driven processes using standardized entity-action descriptions.
- Domain Modeling Workflows - Translates business scenarios into structured domain models to align design concepts with technical implementation.
- Terminology Definitions - The framework defines and refines shared terminology with the model to ensure it understands specific domain requirements and maintains accuracy.
- Iterative System Bootstrapping - Builds and refines system components iteratively by using existing model outputs as a foundation for subsequent improvements.
- Prompt Composition Patterns - Combines multiple prompt strategies into a unified framework to manage complex workflows and multi-stage task execution.
- Negative Prompting - Specifies forbidden content, topics, or styles to prevent the generation of inaccurate, inappropriate, or unwanted information during tasks.
- DSL-Driven Generation - Enables the use of declarative domain-specific languages to define system structures and reduce ambiguity.
- Subdomain Boundaries - Categorizes domain models into logical subdomains to organize complex systems into manageable functional areas.
- Dynamic REST API Generators - Translates domain models into technical specifications and network endpoints.
