designing-systems

Create immutable context files defining technology stacks and architectural constraints.

Updated Aug 2, 2026

Search Tags:#architecture #code generation #technical debt #constraints #spec-driven development #context files

Ready to run

npx skills add https://github.com/bankielewicz/DevForgeAI --skill designing-systems-bankielewicz

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: designing-systems
Source: https://github.com/bankielewicz/DevForgeAI/tree/main/.claude/skills/designing-systems
Command: npx skills add https://github.com/bankielewicz/DevForgeAI --skill designing-systems-bankielewicz

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires pypdf, pdfplumber, pdf2image, and includes scripts (resource) and references (resource) and assets (resource) components.

What problem does it solve?

This Skill establishes the architectural foundation for projects by creating immutable context files that prevent technical debt from assumptions, library substitutions, and structural chaos.

Core Features & Use Cases

Architecture Definition: Define tech stack, project structure, and coding standards.
Constraint Enforcement: Create locked context files (tech-stack.md, etc.) that all other AI agents must follow.
Use Case: When starting a new project, use this Skill to define your technology choices (e.g., .NET 8, Dapper, React) and architectural patterns (e.g., Clean Architecture), ensuring all future development adheres to these constraints.

Quick Start

Use the designing-systems skill to set up project architecture for a new C# backend with React frontend.

Frequently Asked Questions about designing-systems

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

FAQPage Schema

How do I prevent technical debt when using AI agents for code generation?▼

To prevent technical debt during code generation, you establish immutable context files that lock in your technology stack, project structure, and architectural constraints, forcing all AI agents to adhere to spec-driven development rather than making assumptions.

What is spec-driven development and how does it enforce architecture constraints?▼

Spec-driven development is the process of creating locked constraint files defining your tech stack and coding standards. These immutable context files enforce architecture by ensuring every AI agent operates within explicit boundaries, preventing library substitutions and structural chaos.

How do I define a technology stack and project structure for a new software project?▼

You define a technology stack and project structure by generating architecture documentation that explicitly captures your chosen frameworks, dependencies, and coding standards. This establishes a locked project foundation that guides all subsequent development activities.

Can I use architecture context files to enforce Clean Architecture patterns across AI tools?▼

Yes, architecture context files can enforce Clean Architecture patterns by locking specific architectural constraints and anti-patterns into immutable documents. All integrated AI agents must read and follow these files, ensuring structural consistency across tools.

What are the limitations of using locked context files for project structure management?▼

Locked context files prevent technical debt by restricting library substitutions and structural deviations, but they require manual updates when the technology stack fundamentally changes. They enforce immutability, meaning any necessary architectural shifts need deliberate file modifications.

Why does my AI coding assistant substitute libraries and ignore my project structure?▼

AI assistants substitute libraries and ignore project structure when architecture constraints are not explicitly locked. Creating immutable context files with defined tech stacks and anti-patterns forces spec-driven development, stopping the AI from making unauthorized architectural assumptions.