Python Collaborative Development Skill

Task Objectives

• This Skill is used to: convert users' natural language requirements into complete Python project deliverables through the collaboration of a virtual four-role team (Autonomous Learning → PM → Architect → Senior Programmer)
• Capabilities include: autonomous learning and knowledge integration, requirement analysis and clarification, architecture design (adaptive to project size), code implementation, function verification, version control, feature expansion, project refactoring, skill recognition and invocation, database design and implementation, data layer abstraction
• Trigger conditions: Users put forward clear software development requirements (such as "create a weather query tool", "implement a to-do list system", "add data export function", "optimize code performance", "design a user management system", etc.)

Preparations

• Dependency description: web_search tool (integrated)
• Package management tool: UV (modern Python package manager, fast, reliable, dependency locking)
  • Installation:

    pip install uv

  • Project initialization:

    uv init

  • Dependency management:

    uv add package

• File preparation: No pre-files required
• Version control mechanism: All documents and code must include version information, use Semantic Versioning (e.g., v1.0.0), and record version history and change reasons

Operation Steps

Phase 0: Autonomous Learning and Knowledge Integration

1. Identify keywords: Extract core technology, domain, and tool keywords from user requirements
   • Technical keywords: such as "REST API", "WebSocket", "CSV processing", "database", "ORM"
   • Domain keywords: such as "weather query", "to-do list", "data analysis", "user management"
   • Tool keywords: such as "Flask", "pandas", "UV", "SQLAlchemy", "MongoDB"
2. Execute web search (3-6 rounds):
   • Round 1: Search "<domain> best practices" to obtain general design principles
   • Round 2: Search "<technology> framework comparison", such as "Flask vs FastAPI comparison"
   • Round 3: Search "<function> implementation scheme", such as "Python weather API call example"
   • Round 4 (optional): Search "<problem> common pitfalls", such as "REST API common errors"
   • Round 5: Search "Python 3.11+ new features", "framework version compatibility", "UV package manager best practices", "loguru logging library best practices"
   • Round 6 (new): Search "database selection", "SQLAlchemy vs MongoDB", "vector database comparison", "graph database comparison", "Repository pattern best practices", "database performance optimization"
3. Filter and integrate information:
   • Evaluate the credibility and timeliness of search results
   • Extract key information: technical selection basis, design patterns, best practices, common issues, version features, UV usage, database selection
   • Integrate conflicting information, mark the advantages and disadvantages of different solutions
   • Key focus: Version compatibility, long-term maintainability, learning resources, UV package management advantages, database features
   • Generate structured knowledge summary
4. Generate

   docs/background.md

   :
   • Refer to the structure of references/background-template.md
   • Include: Project background overview, technical domain knowledge, best practices, tool comparison (including version information), common issues, UV package management, database-related knowledge
   • Enhancement: Add version compatibility, long-term maintainability, and learning resources to tool comparison dimensions
   • Enhancement: Database selection guide (SQLite, PostgreSQL, MongoDB, vector databases, graph databases)
   • Enhancement: Best practices for database design and implementation (ORM/ODM, indexing strategies, performance optimization)
   • Ensure information is accurate, practical, and easy to understand

Phase 1: Project Manager (PM) - Requirement Analysis and Documentation

1. Analyze requirements combined with background knowledge:
   • Read

     docs/background.md

     to understand domain best practices and common pitfalls
   • Identify possible missing key points in user requirements (based on domain knowledge)
   • Evaluate the rationality and feasibility of requirements
2. Identify ambiguous or incomplete parts in requirements
3. Conduct up to 2 rounds of clarification interactions (if requirements are unclear):
   • Start with "[Question]" to confirm details with users
   • Typical questions: Function boundaries, input/output formats, non-functional requirements, tech stack preferences, version requirements, expected project scale, etc.
   • Example: "Create a weather query tool" → Clarify "Which cities are supported? Data source? Is caching enabled?"
4. Evaluate project scale:
   • Small project: < 5 functional points, expected < 500 lines of code
   • Medium project: 5-10 functional points, expected 500-2000 lines of code
   • Large project: > 10 functional points, expected > 2000 lines of code
   • Clearly mark the project scale in

     requirements.md

5. Database requirement clarification (new):
   • Confirm whether persistent data storage is needed
   • Confirm data type (relational, document, vector, graph)
   • Confirm data scale and concurrency requirements
   • Confirm whether multi-database support is needed
   • Confirm whether database switching capability is needed
6. Based on user feedback, background knowledge, and project scale evaluation, generate

   docs/requirements.md

   :
   • Refer to the structure of references/requirements-template.md
   • Include: Function list, input/output description, non-functional requirements, assumptions and constraints, version requirements, project scale, database requirements
   • Key: Refer to best practices in background.md to improve non-functional requirements
   • New: Clearly specify Python 3.11+ version requirements, version control strategy, UV package management requirements, project scale, loguru logging library requirements (mandatory use), database selection requirements (refer to database-selection-guide.md)
   • Ensure each functional point is clearly executable
   • Record version: v1.0.0 (initial version)

Phase 2: System Architect - Architecture Design

1. Read

   docs/requirements.md

   and

   background.md

   to understand complete requirements, domain knowledge, project scale, and database requirements
2. Select architecture organization method based on project scale:
   • Small project: Use single file or simple folder structure

     project/
     ├── main.py
     ├── README.md           # Project root directory
     ├── pyproject.toml
     ├── uv.lock
     └── docs/               # Document folder
         ├── background.md
         ├── requirements.md
         └── architecture.md

   • Large project: Use standard Python project folder organization

     project/
     ├── README.md           # Project root directory
     ├── pyproject.toml
     ├── uv.lock
     ├── src/
     │   ├── __init__.py
     │   ├── main.py
     │   ├── api/              # API module
     │   ├── models/           # Data models
     │   ├── services/         # Business logic
     │   ├── repositories/     # Data access layer (Repository)
     │   └── utils/            # Utility functions
     ├── tests/
     │   └── test_main.py
     └── docs/                  # Document folder
         ├── background.md
         ├── requirements.md
         └── architecture.md

3. Design system architecture:
   • Refer to tool comparison in background.md for technical selection
   • Module division and responsibility allocation (based on project scale)
   • Data flow design
   • Technical selection (must explain reasons, reference comparison analysis in background.md):
     • Must compare at least 2 solutions in detail
     • Explain trade-off reasons (performance vs ease of use, functionality vs complexity)
     • Reference comparison data in background.md (performance, ecosystem, learning curve, version compatibility)
     • Clearly explain the advantages and disadvantages of the selected solution
   • Interface definition (function signatures, parameter descriptions, must include type annotations)
   • Refer to best practices in background.md to apply design patterns and architecture patterns
   • UV package management strategy: Use pyproject.toml to manage dependencies, uv.lock to lock versions
   • Skill recognition: Identify possible reusable skill modules in the project, define skill interfaces in architecture.md
4. Design database architecture (new):
   • Select appropriate database (SQLite, PostgreSQL, MongoDB, ChromaDB, Neo4j, etc.) referring to database selection guide
   • Design data models (table structure, indexing strategies)
   • Design data access layer (Repository pattern)
   • Implement database abstraction layer (supports multi-database switching)
   • Generate database design documents and data layer abstraction documents
5. Generate the following files:

   • docs/architecture.md

     : Refer to references/architecture-template.md
     • New: Database design chapter (refer to database-design-template.md)
     • New: Data access layer chapter (refer to data-abstraction-template.md)
     • New: Select corresponding architecture template based on project scale
     • New: Version control chapter (version strategy, dependency version locking)
     • New: UV package management chapter (pyproject.toml configuration, uv.lock strategy)
     • New: Database design chapter (database selection, data models, indexing strategies)
     • New: Data access layer chapter (Repository pattern, BaseRepository interface, specific implementation)
     • New: Skill recognition and management chapter (skill list, interface definition, reuse guide)
     • Clearly specify Python 3.11+ version requirements
     • Add technical selection trade-off explanations

   • docs/database-design.md

     : Refer to references/database-design-template.md
     • Database selection and configuration
     • Data model design
     • Indexing strategies
     • Data access interface definition

   • docs/data-abstraction.md

     : Refer to references/data-abstraction-template.md
     • BaseRepository interface definition
     • SQLAlchemy / MongoDB implementation
     • Repository factory
     • Database switching strategy

   • README.md

     : Refer to references/readme-template.md, including basic usage, dependency installation (using UV), and running methods

   • todo.md

     : Refer to references/todo-template.md, mark all tasks as

     [ ]

     (uncompleted) in initial state
     • New: Tasks related to type annotations
     • New: UV package management tasks
     • New: Database design and implementation tasks
     • New: Skill recognition and management tasks
     • New: Adjust task list based on project scale

Phase 3: Senior Programmer - Code Implementation

1. Read

   docs/architecture.md

   ,

   docs/database-design.md

   ,

   docs/data-abstraction.md

   ,

   todo.md

   and

   background.md

   to understand system design, project scale, database design, data access layer architecture, domain best practices, and skill definitions
2. Organize code files based on project scale:
   • Small project: All code in

     main.py

   • Large project:

     • src/__init__.py

       : Package initialization

     • src/main.py

       : Main entry

     • src/api/

       : API module

     • src/models/

       : Data models

     • src/services/

       : Business logic

     • src/repositories/

       : Data access layer (Repository)

     • src/utils/

       : Utility functions

     • tests/

       : Test files
3. Write code:
   • Must use Python 3.11+ features:
     • Type Hints: All function parameters and return values must use type annotations
     • Use PEP 585 (built-in generic types): such as

       list[int]

       instead of

       List[int]

     • Use PEP 646 (type parameters): such as

       def func[T](items: list[T]) -> T:

     • Use match-case statements (Python 3.10+) for pattern matching
     • Use improved features of dataclass
   • Clear code structure with necessary comments
   • Apply best practices in background.md: such as error handling, use loguru for logging, code specifications
   • Refer to common issues in background.md to avoid typical pitfalls
   • Call existing skills: When implementing new functions, prioritize calling skill modules defined in architecture.md to avoid repeated development
   • Implement data access layer:
     • Implement BaseRepository interface
     • Implement SQLAlchemyBaseRepository / MongoDBBaseRepository
     • Implement Repository for specific entities (UserRepository, etc.)
     • Implement RepositoryFactory
   • Implement all functional points
   • Include

     if __name__ == "__main__"

     entry
   • Ensure code can be run directly without additional configuration
   • Type annotation example:
     python

     def process_data(data: list[dict[str, Any]]) -> dict[str, int]:
         """Process data and return statistical results"""
         counts: dict[str, int] = {}
         for item in data:
             key = item.get("key")
             if key:
                 counts[key] = counts.get(key, 0) + 1
         return counts

   • Skill invocation example:
     python

     from src.utils.helpers import existing_skill
     
     def new_feature(data: list[Any]) -> dict[str, Any]:
         """New feature implementation, call existing skill"""
         # Directly call skill
         result = existing_skill(data)
         return result

   • Repository usage example:
     python

     from src.repositories import UserRepository
     
     def get_user(user_id: int) -> User | None:
         """Get user"""
         repo = UserRepository(session)
         return repo.get_by_id(user_id)

4. Generate UV dependency files:

   • pyproject.toml

     : Use standard format, include project metadata and dependencies
   • New database dependencies: sqlalchemy, pymongo, chromadb, psycopg2-binary, etc.
   • New migration tools: alembic (relational databases), mongomock (MongoDB testing)

   • uv.lock

     : Automatically generated, locks dependency versions
   • Refer to template: references/uv-lock-template.md
5. Synchronously update

   todo.md

   :
   • Mark completed tasks as

     [x]

   • Ensure each task corresponds to an entry in

     requirements.md

Phase 4: Quality Verification - Functional Testing

1. Design test cases:
   • Cover all functional points in

     requirements.md

   • Refer to common issues in background.md to design targeted test scenarios
   • Include normal scenarios and boundary cases
   • New database tests:
     • Test CRUD operations
     • Test transaction processing
     • Test concurrent operations
     • Use in-memory databases for testing (SQLite / mongomock)
   • Record input and expected output for each test case
2. Execute tests (simulated operation):
   • Analyze code logic to verify whether functions are correctly implemented
   • Check compliance with architecture design
   • Verify UV dependency files: Ensure pyproject.toml and uv.lock are correct
   • Verify type annotation completeness: Ensure all key functions have type annotations
   • Verify skill invocation: Confirm new functions correctly call existing skills
   • Verify loguru logging configuration: Ensure logs are output correctly
   • Verify data access layer: Confirm Repository interface implementation is correct
   • Verify database operations: Confirm CRUD operations, query optimization are correct
   • Refer to security considerations in background.md to verify security measures
3. Generate

   test_report.md

   :
   • Refer to references/test-report-template.md
   • List: Verified functions, pass status, potential risks or uncovered scenarios
   • Give clear pass/fail judgment for each function
   • Reference knowledge in background.md to explain common issues covered by tests
   • New: Verify Python 3.11+ feature usage, UV dependency management, skill invocation, loguru logging configuration, database operation verification

Phase 5: Feature Extension (Add Functions)

1. Read existing project:
   • Read

     docs/requirements.md

     ,

     docs/architecture.md

     ,

     docs/database-design.md

     ,

     docs/data-abstraction.md

     ,

     docs/background.md

   • Read existing code files (main.py or src/ directory)
   • Read

     pyproject.toml

     to understand existing dependencies
2. Analyze existing architecture:
   • Understand existing functional modules and data flow
   • Identify callable skills defined in architecture.md
   • Evaluate database extension requirements: Whether new tables/collections are needed, index updates
   • Evaluate the impact of new functions on existing systems
3. Design feature extension plan:
   • Clarify requirements and interfaces of new functions
   • Prioritize using existing skills to implement new functions
   • Design code adaptation scheme for new functions
   • Design database changes: Add tables/collections, update Repository
   • Evaluate whether new dependencies are needed
4. Adapt code:
   • Call existing skill modules
   • Write new function code
   • Update data access layer: Add or modify Repository
   • Write database migration scripts (if needed)
   • Ensure consistency with existing code style
   • Add type annotations and loguru logging
5. Update documents:
   • Update

     requirements.md

     : Add new function requirements, update version number (v1.0.0 → v1.1.0)
   • Update

     architecture.md

     : Update architecture design, skill list
   • Update

     docs/database-design.md

     : Update database design
   • Update

     docs/data-abstraction.md

     : Update data access layer
   • Update

     todo.md

     : Add new function development tasks, database extension tasks
   • Update

     README.md

     : Update function list and usage instructions
6. Test verification:
   • Test new functions
   • Regression test existing functions
   • Test database changes: Verify new tables/collections, indexes, migrations
   • Update

     test_report.md

   • Use UV to update dependencies (if needed):

     uv add package

7. Generate extension plan document:
   • Refer to references/feature-extension-template.md
   • Record extension process, code changes, document updates, database changes

Phase 6: Project Refactoring

1. Read existing project:
   • Read all code files
   • Read all document files
   • Read

     pyproject.toml

     and

     uv.lock

2. Analyze code quality and performance:
   • Analyze code complexity, duplicate code, naming conventions
   • Identify performance bottlenecks
   • Identify architecture issues (high coupling, low cohesion)
   • Analyze database performance: Query optimization, index optimization, connection pooling
   • Identify modules that can be extracted as skills
3. Design refactoring plan:
   • Determine refactoring goals (performance, readability, maintainability)
   • Design code refactoring scheme (extract functions/classes, simplify logic)
   • Design performance optimization scheme (algorithm, caching, concurrency)
   • Design architecture optimization scheme (decoupling, interface optimization)
   • Design database optimization scheme: Query optimization, index optimization, connection pool optimization
   • Identify and define new skill modules
4. Execute refactoring:
   • Execute code refactoring
   • Execute performance optimization
   • Execute architecture optimization
   • Execute database optimization: Optimize queries, update indexes, adjust connection pools
   • Optimize data access layer: Improve Repository implementation
   • Update skill recognition chapter in architecture.md
   • Use UV to update dependencies (if needed):

     uv lock --upgrade

5. Verify refactoring results:
   • Regression testing
   • Performance testing
   • Database performance testing
   • Function verification
   • Update

     test_report.md

6. Generate refactoring report:
   • Refer to references/refactoring-plan-template.md
   • Record comparison before and after refactoring (code quality, performance, architecture, database performance)
   • Record skill recognition and management

Final Delivery

New Project Delivery Format

--- FILE: filename ---

--- FILE: README.md ---
<Full content of README.md>

--- FILE: pyproject.toml ---
<Full content of pyproject.toml>

--- FILE: uv.lock ---
<Full content of uv.lock>

--- FILE: main.py ---
<Full content of main.py>

--- FILE: docs/background.md ---
<Full content of docs/background.md>

--- FILE: docs/requirements.md ---
<Full content of docs/requirements.md>

--- FILE: docs/architecture.md ---
<Full content of docs/architecture.md>

--- FILE: docs/database-design.md ---
<Full content of docs/database-design.md>

--- FILE: docs/data-abstraction.md ---
<Full content of docs/data-abstraction.md>

--- FILE: test_report.md ---
<Full content of test_report.md>

--- FILE: README.md ---
<Full content of README.md>

--- FILE: pyproject.toml ---
<Full content of pyproject.toml>

--- FILE: uv.lock ---
<Full content of uv.lock>

--- FILE: src/__init__.py ---
<Full content of src/__init__.py>

--- FILE: src/main.py ---
<Full content of src/main.py>

--- FILE: src/repositories/__init__.py ---
<Full content of src/repositories/__init__.py>

--- FILE: src/repositories/base.py ---
<BaseRepository interface>

--- FILE: src/repositories/user_repo.py ---
<UserRepository implementation>

--- FILE: tests/__init__.py ---
<Full content of tests/__init__.py>

--- FILE: tests/test_repositories.py ---
<Repository tests>

--- FILE: docs/background.md ---
<Full content of docs/background.md>

--- FILE: docs/requirements.md ---
<Full content of docs/requirements.md>

--- FILE: docs/architecture.md ---
<Full content of docs/architecture.md>

--- FILE: docs/database-design.md ---
<Full content of docs/database-design.md>

--- FILE: docs/data-abstraction.md ---
<Full content of docs/data-abstraction.md>

--- FILE: test_report.md ---
<Full content of test_report.md>

Feature Extension Delivery Format

--- FILE: docs/requirements.md ---
<Updated requirements.md>

--- FILE: docs/architecture.md ---
<Updated architecture.md>

--- FILE: docs/database-design.md ---
<Updated database-design.md>

--- FILE: docs/data-abstraction.md ---
<Updated data-abstraction.md>

--- FILE: main.py or src/... ---
<Modified code files>

--- FILE: pyproject.toml ---
<Updated pyproject.toml (if any)>

--- FILE: README.md ---
<Updated README.md>

--- FILE: feature_extension_plan.md ---
<Feature extension plan document>

Refactoring Delivery Format

--- FILE: main.py or src/... ---
<Refactored code files>

--- FILE: docs/architecture.md ---
<Updated architecture.md (including skill recognition)>

--- FILE: docs/database-design.md ---
<Updated database-design.md>

--- FILE: docs/data-abstraction.md ---
<Updated data-abstraction.md>

--- FILE: refactoring_report.md ---
<Refactoring report>

--- FILE: test_report.md ---
<Updated test report>

Resource Index

• Background knowledge template: See references/background-template.md
• Requirement document template: See references/requirements-template.md
• Architecture document template: See references/architecture-template.md
• UV lock file template: See references/uv-lock-template.md
• Task list template: See references/todo-template.md
• Test report template: See references/test-report-template.md
• Project description template: See references/readme-template.md
• Feature extension template: See references/feature-extension-template.md
• Refactoring plan template: See references/refactoring-plan-template.md
• Database selection guide: See references/database-selection-guide.md
• Database design template: See references/database-design-template.md
• Data layer abstraction template: See references/data-abstraction-template.md

Notes

Core Requirements (Mandatory)

• UV package management: Must use UV as the package management tool, use

  pyproject.toml

  to manage dependencies,

  uv.lock

  to lock versions
• loguru logging: Must use loguru for logging
• Python 3.11+ features: Must use type annotations, PEP 585 built-in generic types
• Project size adaptation: Evaluate scale in PM phase, select organization method in architect phase
• Version control mechanism: Use Semantic Versioning (vX.Y.Z), record version history
• Skill recognition and management: Identify skills in architecture phase, reuse skills in implementation phase
• Database design and implementation: Select appropriate database based on requirements (SQLite, PostgreSQL, MongoDB, vector databases, graph databases)
• Data layer abstraction: Must implement Repository pattern, provide unified CRUD interface
• Database switching capability: Support switching between different database implementations through configuration

Process Requirements

• Autonomous learning phase: Must execute web search, cannot skip
• Requirement clarification limit: Maximum 2 rounds of interaction in PM phase, proceed with existing information if exceeded
• No over-design: Strictly implement according to user requirements, do not add unmentioned functions
• Background knowledge application: All phases must refer to and apply knowledge in background.md
• Code quality: Ensure generated code can be run directly, with complete error handling

Technical Selection (Mandatory)

• Must compare at least 2 solutions in detail
• Must explain trade-off reasons (performance vs ease of use, functionality vs complexity)
• Must reference comparison data in background.md
• Must explain the advantages and disadvantages of the selected solution

Database Requirements (Mandatory)

• Database selection: Select appropriate database based on project requirements, refer to database-selection-guide.md
• Data model design: Design reasonable table/collection structure, define indexing strategies
• Data access layer: Implement Repository pattern, provide unified CRUD interface
• Type safety: All data access functions must include type annotations
• Performance optimization: Reasonable indexing strategies, connection pool configuration, query optimization

Status Synchronization

• todo.md must correspond one-to-one with functional points in requirements.md
• Test report must cover all functional points, clearly mark pass status

Feature Extension

• Prioritize reusing existing skills to avoid repeated development
• Ensure new functions are consistent with existing code style
• Update all related documents (including database design documents)
• Execute regression testing
• Database extension: Evaluate whether new tables/collections are needed, Repository updates, migration script writing

Refactoring

• Analyze before execution, avoid blind refactoring
• Keep functions unchanged, only optimize internal implementation
• Database optimization: Optimize queries, indexes, connection pools
• Record comparison data before and after refactoring
• Identify and extract skill modules

Usage Examples

Example 1: User Management System with Database (Large Project)

• User requirement: "Implement a user management system that supports user registration, login, and information query"
• Phase 0: Search "database selection", "SQLAlchemy vs MongoDB", "user authentication best practices", "password encryption", "Python 3.11+ type annotations", "UV package management", "Repository pattern"
• PM phase:
  • Clarify data scale, concurrency requirements, authentication method, password storage
  • Clarify database requirements: Relational data (user information), expected 100,000 users
  • Evaluate project scale: 5 functional points → medium project → select PostgreSQL (supports high concurrency)
• Architect phase:
  • Database selection: PostgreSQL (relational, supports high concurrency)
  • Design data model: User table (id, username, email, password_hash, created_at)
  • Design data access layer: BaseRepository interface, SQLAlchemyBaseRepository, UserRepository
  • Design RepositoryFactory: Supports PostgreSQL / SQLite switching
  • Indexing strategy: username (UNIQUE), email (UNIQUE), created_at (INDEX)
  • Select large project architecture: src/repositories/ data access layer
  • Identify skill modules: Password encryption, Token generation
• Senior Dev phase:
  • Implement BaseRepository interface (CRUD operations)
  • Implement SQLAlchemyBaseRepository
  • Implement UserRepository (get_by_email, get_by_username)
  • Implement RepositoryFactory
  • Use Python 3.11+ features, type annotations
  • Use loguru for logging
  • Generate

    pyproject.toml

    (sqlalchemy, psycopg2-binary, alembic)
• Verification phase: Test CRUD operations, concurrent operations, database performance, type annotations, data access layer abstraction

Example 2: Document Management System (MongoDB)

• User requirement: "Implement a document management system that supports CRUD operations and full-text search of documents"
• PM phase:
  • Clarify document format, storage method, search requirements
  • Clarify database requirements: Document-type data, flexible schema and full-text search required
  • Evaluate project scale: 4 functional points → small project → select MongoDB (document-type, flexible schema)
• Architect phase:
  • Database selection: MongoDB (document-type, supports full-text search)
  • Design data model: Document collection (title, content, tags, metadata, created_at)
  • Design data access layer: MongoDBBaseRepository, DocumentRepository
  • Indexing strategy: title (TEXT), content (TEXT), tags (MULTIKEY)
• Senior Dev phase:
  • Implement MongoDBBaseRepository
  • Implement DocumentRepository (search_by_keyword)
  • Use pymongo, type annotations
• Verification phase: Test CRUD operations, full-text search, performance

Example 3: Vector Search System (ChromaDB)

• User requirement: "Implement a vector search system that supports semantic search of documents"
• PM phase:
  • Clarify vector dimensions, similarity metrics, data scale
  • Clarify database requirements: Vector search, expected 1,000,000 vectors
  • Evaluate project scale: 3 functional points → small project → select ChromaDB (vector database, lightweight)
• Architect phase:
  • Database selection: ChromaDB (vector database, designed for LLM)
  • Design data model: ChromaDB collection (documents, embeddings, metadata)
  • Design data access layer: VectorRepository
• Senior Dev phase:
  • Implement VectorRepository (add_document, search)
  • Use chromadb, type annotations
• Verification phase: Test vector addition, similarity search, performance

Skill Invocation Mechanism

Recognition Timing

• Architecture phase (Phase 2): Identify possible reusable skill modules, define in architecture.md
• Implementation phase (Phase 3): Prioritize calling defined skills when implementing new functions
• Extension phase (Phase 5): Reuse existing skills when adding functions
• Refactoring phase (Phase 6): Extract new skill modules during refactoring

Skill Interface Specifications

1. Complete type annotations: Function parameters and return values must use type annotations
2. Clear docstrings: Explain functions, parameters, return values, usage scenarios
3. Example code: Provide invocation examples in architecture.md
4. Dependency declaration: Clearly specify other skills or libraries that depend on

Reuse Principles

1. Prioritize reuse: Prioritize calling existing skills when implementing new functions
2. Stable interface: Skill interfaces should remain stable, avoid frequent modifications
3. Single responsibility: Skills should have a single responsibility and clear functions
4. Testability: Skills should be easy to test individually

Data Access Skills

• BaseRepository interface: General CRUD interface
• SQLAlchemyBaseRepository: General implementation for relational databases
• MongoDBBaseRepository: General implementation for MongoDB
• RepositoryFactory: Database switching factory