Self-generation of .rules/AGENT.md

[Cretezy]

Hi. I've been working on a prompt which can help scaffold .rules files with a basic overview of the project being worked on. I think having a built-in method of running this prompt (e.g. a menu item in the agent panel's top-right menu called "Generate rules") could be useful, and I'm currently looking for feedback on this feature before starting implementation. This feature isn't required to run the following prompt, although having a one-click button would definitely simplify it's usage.

Here's the prompt:

Your goal is to produce a file called `.rules` which explains the outline of the project, so that you (the AI agent) can navigate and modify the project swiftly.

In the file, include information such as:
- Which language(s) the project is written in
- Which tools (such as package manager) and libraries/frameworks (only include major or relevant ones) does the project use, include key components (auth, logging, styling, etc)
- The structure of the project (if it's split into multiple sub-modules, enumerate what each does, and include information on them)
- How the project is deployed (include some information on infrastructure and CI/CD)
- Basic project style guides and guide lines, if applicable

Look at directory structures, relevant language-specific files (e.g. package.json or Cargo.toml), and specific files if you need to understand what they do.

Keep it informative but concise, as a future AI agent will be reading it. Make sure to include any information that may help you answer future queries by the user.

I've found this generates a very strong base of the .rules file to be refined by a human after. I've tested this with Sonnet 4 and Gemini 2.5 Pro/Flash, and they have all yielded good results (I haven't tested other models, but I assume most SOTA models would give good results too).

Here's an example of the prompt's result on Zed's codebase

Zed Project Rules and Structure

Overview

Zed is a high-performance, multiplayer code editor written in Rust. It's built from the ground up with collaboration, AI integration, and extensibility as core features.

Language and Toolchain

• Primary Language: Rust (edition 2021, toolchain 1.88)
• Package Manager: Cargo with workspace configuration
• Code Quality: Uses clippy and rustfmt with custom configurations
• Target Platforms: macOS, Linux, FreeBSD (Windows in development)
• Architecture: x86_64 and aarch64 (Apple Silicon)

Core Technologies and Frameworks

GUI Framework

• GPUI: Custom GPU-accelerated UI framework (primary UI layer)
• Rendering: Metal (macOS), Vulkan/OpenGL (Linux), DirectX planned (Windows)
• Features: Wayland and X11 support on Linux

Key Libraries and Services

• Database: PostgreSQL with sqlx/sea-orm
• Real-time Collaboration: LiveKit for audio/video/screen sharing
• Blob Storage: MinIO/S3 compatible storage
• Networking: Tokio async runtime, tungstenite WebSockets
• Language Support: Tree-sitter for syntax highlighting, LSP for language features
• AI Integration: Multiple providers (OpenAI, Anthropic, Google AI, Mistral, etc.)
• Version Control: Git (git2) and Jujutsu (jj-lib)
• Extensions: WASM-based with wasmtime runtime

Project Structure

Workspace Organization

The project uses a Cargo workspace with 180+ internal crates organized in /crates/:

Core Infrastructure

• gpui: GPU-accelerated UI framework
• util: Common utilities and macros
• collections: Custom collection types
• fs: File system abstraction
• rpc: Remote procedure call system
• proto: Protocol definitions

Editor Core

• editor: Core text editing functionality
• text: Text manipulation and rope data structure
• language: Language support and LSP integration
• project: Project management and file operations
• workspace: Workspace and pane management
• buffer_diff: Text diffing algorithms

UI Components

• ui: Base UI components and styling
• theme: Theme system and management
• menu: Menu system
• picker: Fuzzy finder interface
• command_palette: Command palette implementation
• terminal_view: Integrated terminal

Features

• search: Search and replace functionality
• diagnostics: Error/warning display
• copilot/supermaven: AI code completion
• vim: Vim keybindings mode
• git_ui: Git integration UI
• debugger_ui: Debug adapter protocol support
• extensions_ui: Extension management

Collaboration

• collab: Server-side collaboration logic
• collab_ui: Client-side collaboration UI
• call: Audio/video calling features
• channel: Team channels and messaging
• client: Client networking layer

AI Integration

• language_model: AI language model abstraction
• language_models: Collection of LLM providers
• assistant_*: AI assistant features and tools
• anthropic, open_ai, google_ai: Provider-specific implementations

Extension System

• extension: Core extension runtime
• extension_host: Extension hosting and management
• language_extension: Language-specific extensions
• Extensions are WASM modules in /extensions/

Key Directories

• /assets/: Icons, fonts, and other static resources
• /docs/: Documentation (mdBook format)
• /script/: Build, deployment, and utility scripts
• /extensions/: Built-in and example extensions
• /.github/workflows/: CI/CD pipeline definitions

Development Guidelines

Code Style

• Follow Rust standard formatting (rustfmt)
• Use clippy with project-specific configuration
• Allow private module inception for clean organization
• Prefer explicit error handling with anyhow::Result
• Use workspace dependencies for consistency

Architecture Patterns

• GPUI Components: UI follows component-based architecture
• Actions: Use typed action system for editor commands
• Settings: Centralized settings management with schema validation
• Async: Heavy use of async/await with Tokio runtime
• Error Handling: Consistent error propagation with context

Testing

• Unit tests in individual crates
• Integration tests for editor functionality
• UI tests using GPUI test support
• Randomized testing for collaboration features

Build and Deployment

Build System

• Standard Cargo build with workspace optimization
• Platform-specific bundling scripts in /script/
• Different profiles: dev, release, release-fast
• Custom bundle metadata for different release channels

CI/CD Pipeline

• GitHub Actions: Main CI pipeline
• Multi-platform: Builds for macOS, Linux, FreeBSD
• Release Channels: Dev, Nightly, Preview, Stable
• Quality Gates: Tests, clippy, license checks, link validation

Infrastructure

• Collaboration Server: Rust service with PostgreSQL backend
• Database: PostgreSQL with migrations system
• Blob Storage: MinIO/S3 for file storage
• Real-time: LiveKit server for collaboration features
• Deployment: Docker containers with compose configuration

Extension Development

• Extensions written in Rust, compiled to WASM
• Extension API provides language server integration
• Theme and language extensions supported
• Extensions distributed through Zed's extension registry

Key Configuration Files

• Cargo.toml: Workspace and dependency management
• rust-toolchain.toml: Rust version pinning
• clippy.toml: Linting configuration
• .github/workflows/ci.yml: Main CI pipeline
• compose.yml: Local development services
• Various Dockerfile-*: Container definitions for different services

Development Workflow

1. Use script/bootstrap for initial setup
2. cargo run starts the development version
3. script/linux or script/bundle-mac for platform builds
4. Extensions developed with script/zed-local --dev-server-token
5. Collaboration tested with local Docker services

This structure enables rapid development while maintaining code quality and supporting the complex requirements of a modern collaborative code editor.