К основному содержанию
скилл CX Codex

continuous-learning-construction — скилл для Claude Code: обучение

Скилл continuous-learning-construction извлекает из сессий по строительной автоматизации решения и повторно используемые шаблоны. Пригодится после расчётов, обработки документов и настройки интеграций.

MIT 118 установок ★ 434 обновлён 2026-10-19

Установить в Claude Code · Через Skills CLI (Vercel) Все способы и платформы ↓
npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill continuous-learning-construction -a claude-code
Открыть на GitHub

Что делает continuous-learning-construction

Скилл разбирает историю сессии и собирает успешные решения, способы исправления ошибок, приёмы оптимизации, шаблоны интеграций и повторно используемый код. Среди категорий — оценка стоимости, обработка данных BIM, планирование и контроль качества.

В примерах описан конвейер, который проверяет новые шаблоны, ищет похожие в базе знаний и сохраняет результаты. Для Revit он предлагает искать уровень элемента сначала в параметре Level, затем в Reference Level, а при необходимости вычислять по координате Z. Примеры также охватывают повторные запросы к Procore при ограничении частоты и упрощение запросов CWICR без результатов.

Скилл рассчитан на анализ журналов сессий, поэтому агенту нужно передать контекст проделанной работы. Описанный конвейер сохраняет шаблоны в базе знаний; конкретные детали применения сохранённых знаний в этой версии описания не раскрыты.

Какие задачи решает

  • сохранять удачные решения из сессий автоматизации
  • фиксировать способы устранения ошибок обработки
  • выделять повторяемые приёмы оценки стоимости
  • записывать шаблоны интеграции с API
  • находить повторно используемые фрагменты кода

Примеры запросов агенту

  • Разбери эту сессию по строительной автоматизации и сохрани пригодные для повторного использования решения.
  • Выдели из журнала ошибки обработки данных и шаги, которые помогли их устранить.
  • Запиши шаблон обработки элементов Revit, если он следует из этой сессии.

Как установить continuous-learning-construction

1Через Skills CLI (Vercel)

npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill continuous-learning-construction -a claude-code

2Вручную: положить файлы

~/.claude/skills/continuous-learning/SKILL.md

Папка скилла целиком; для одного проекта — .claude/skills/continuous-learning/

По шагам, с командами для каждой платформы: Как установить скилл в Claude Code: пять способов

Вопросы о continuous-learning-construction

Как установить continuous-learning-construction в Claude Code?

Выполните npx skills add datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill continuous-learning-construction -a claude-code.

Что делает continuous-learning-construction?

Анализирует историю сессий автоматизации строительства и выделяет решения, исправления ошибок, шаблоны интеграции и повторно используемый код. Конвейер сохраняет проверенные шаблоны в базе знаний.

Какие строительные задачи охватывают примеры скилла?

Примеры включают оценку стоимости, извлечение уровней из данных Revit, обработку ограничений Procore API и поиск решений для запросов CWICR без подходящих совпадений.

Исходный текст

SKILL.md · MIT
---
name: "continuous-learning-construction"
description: "Automatically extract patterns, best practices, and reusable knowledge from construction automation sessions to improve future performance."
homepage: "https://datadrivenconstruction.io"
metadata: {"openclaw": {"emoji": "🛡️", "os": ["win32"], "homepage": "https://datadrivenconstruction.io", "requires": {"bins": ["python3"]}}}
---
# Continuous Learning for Construction Automation

This skill enables automatic extraction of valuable patterns, solutions, and best practices from construction automation sessions to build institutional knowledge.

## When to Use

Activate this skill:
- At the end of complex estimation sessions
- After solving non-trivial data processing problems
- When discovering new integration patterns
- After completing successful document processing
- When developing new automation workflows

## Pattern Extraction Framework

### 1. Session Analysis

```python
class ConstructionSessionAnalyzer:
    """Extract learnings from automation sessions"""

    # Categories of learnable patterns
    PATTERN_CATEGORIES = [
        'data_processing',      # Data transformation patterns
        'estimation',           # Cost estimation techniques
        'scheduling',           # Schedule optimization patterns
        'integration',          # API/system integration patterns
        'document_processing',  # Document handling patterns
        'quality_assurance',    # Validation and QA patterns
        'error_handling',       # Error resolution patterns
        'optimization'          # Performance optimization patterns
    ]

    def analyze_session(self, session_log: list) -> dict:
        """Extract patterns from session history"""

        patterns = {
            'successful_solutions': [],
            'error_resolutions': [],
            'optimization_discoveries': [],
            'integration_patterns': [],
            'reusable_code': [],
            'decision_rationales': []
        }

        for entry in session_log:
            if self._is_solution(entry):
                patterns['successful_solutions'].append(
                    self._extract_solution_pattern(entry)
                )

            if self._is_error_resolution(entry):
                patterns['error_resolutions'].append(
                    self._extract_error_pattern(entry)
                )

            if self._is_optimization(entry):
                patterns['optimization_discoveries'].append(
                    self._extract_optimization(entry)
                )

        return patterns
```

### 2. Knowledge Categories for Construction

#### 2.1 Cost Estimation Patterns

```yaml
# Example learned pattern
pattern:
  name: "electrical_cost_adjustment_pattern"
  category: "estimation"
  context: "When estimating electrical work for high-rise buildings"
  problem: "Standard rates don't account for vertical transportation costs"
  solution: |
    Apply height factor multiplier:
    - Floors 1-5: 1.0x base rate
    - Floors 6-15: 1.15x base rate
    - Floors 16-30: 1.25x base rate
    - Floors 30+: 1.35x base rate
  confidence: 0.85
  source_sessions: ["session_2026_01_15", "session_2026_01_20"]
  validations: 3
```

#### 2.2 BIM Data Processing Patterns

```yaml
pattern:
  name: "revit_level_extraction"
  category: "data_processing"
  context: "Extracting elements by level from Revit exports"
  problem: "Elements sometimes missing level association"
  solution: |
    1. First check 'Level' parameter
    2. If missing, check 'Reference Level' parameter
    3. If still missing, derive from bounding box Z coordinate
    4. Map Z ranges to known level elevations
  code_snippet: |
    def get_element_level(element: dict, levels: list) -> str:
        # Direct level parameter
        if level := element.get('Level'):
            return level

        # Reference level fallback
        if ref_level := element.get('Reference Level'):
            return ref_level

        # Derive from geometry
        z_coord = element['BoundingBox']['Min']['Z']
        return find_nearest_level(z_coord, levels)
  confidence: 0.92
```

#### 2.3 Integration Patterns

```yaml
pattern:
  name: "procore_rate_limit_handling"
  category: "integration"
  context: "Syncing data with Procore API"
  problem: "API returns 429 Too Many Requests during bulk operations"
  solution: |
    Implement exponential backoff with jitter:
    1. Initial delay: 1 second
    2. Multiply by 2 on each retry
    3. Add random jitter (0-500ms)
    4. Max retries: 5
    5. Max delay: 32 seconds
  code_snippet: |
    async def procore_request_with_retry(url, data):
        delay = 1
        for attempt in range(5):
            try:
                response = await procore_api.post(url, data)
                return response
            except RateLimitError:
                jitter = random.uniform(0, 0.5)
                await asyncio.sleep(delay + jitter)
                delay *= 2
        raise MaxRetriesExceeded()
  confidence: 0.95
```

#### 2.4 Error Resolution Patterns

```yaml
pattern:
  name: "cwicr_no_match_resolution"
  category: "error_handling"
  context: "CWICR semantic search returns no relevant matches"
  problem: "Query too specific or uses non-standard terminology"
  solution: |
    Resolution steps:
    1. Simplify query to core concepts
    2. Remove brand names and specifications
    3. Try alternative terminology (US vs UK terms)
    4. Expand search to parent category
    5. If still no match, flag for manual mapping
  examples:
    - original: "Kohler K-4519 wall-mounted water closet"
      simplified: "wall mounted toilet"
    - original: "Lutron Caseta wireless dimmer switch"
      simplified: "dimmer switch"
  confidence: 0.88
```

### 3. Learning Pipeline

```python
class ConstructionLearningPipeline:
    """Continuous learning pipeline for construction automation"""

    def __init__(self, knowledge_base_path: str):
        self.kb_path = knowledge_base_path
        self.patterns = self._load_patterns()

    def learn_from_session(self, session: dict) -> list:
        """Extract and store learnings from session"""

        # Analyze session
        analyzer = ConstructionSessionAnalyzer()
        new_patterns = analyzer.analyze_session(session['log'])

        # Validate patterns
        validated = []
        for pattern in new_patterns['successful_solutions']:
            if self._validate_pattern(pattern):
                # Check if similar pattern exists
                existing = self._find_similar_pattern(pattern)
                if existing:
                    # Reinforce existing pattern
                    self._reinforce_pattern(existing, pattern)
                else:
                    # Add new pattern
                    self._add_pattern(pattern)
                validated.append(pattern)

        # Persist to knowledge base
        self._save_patterns()

        return validated

    def apply_learnings(self, context: dict) -> list:
        """Retrieve relevant patterns for current context"""

        relevant_patterns = []

        for pattern in self.patterns:
            similarity = self._calculate_similarity(pattern['context'], context)
            if similarity > 0.7:
                relevant_patterns.append({
                    'pattern': pattern,
                    'relevance': similarity
                })

        return sorted(relevant_patterns, key=lambda x: x['relevance'], reverse=True)

    def _validate_pattern(self, pattern: dict) -> bool:
        """Validate pattern before adding to knowledge base"""

        # Check minimum confidence
        if pattern.get('confidence', 0) < 0.6:
            return False

        # Check for code quality (if code snippet)
        if code := pattern.get('code_snippet'):
            if not self._is_valid_code(code):
                return False

        # Check for completeness
        required_fields = ['name', 'category', 'context', 'solution']
        if not all(f in pattern for f in required_fields):
            return False

        return True
```

### 4. Knowledge Base Structure

```
knowledge_base/
├── patterns/
│   ├── estimation/
│   │   ├── height_factors.yaml
│   │   ├── material_adjustments.yaml
│   │   └── labor_productivity.yaml
│   ├── data_processing/
│   │   ├── revit_extraction.yaml
│   │   ├── ifc_parsing.yaml
│   │   └── excel_transformations.yaml
│   ├── integration/
│   │   ├── procore_patterns.yaml
│   │   ├── plangrid_patterns.yaml
│   │   └── webhook_handlers.yaml
│   └── error_handling/
│       ├── cwicr_resolutions.yaml
│       ├── api_errors.yaml
│       └── data_validation.yaml
├── code_snippets/
│   ├── python/
│   ├── javascript/
│   └── sql/
├── decision_trees/
│   ├── estimate_type_selection.yaml
│   ├── schedule_method_selection.yaml
│   └── integration_approach.yaml
└── metrics/
    ├── pattern_usage.json
    └── success_rates.json
```

### 5. Session End Learning Prompt

At the end of each construction automation session:

```markdown
## Session Learning Review

### What Worked Well
- [Successful approaches discovered]
- [Efficient patterns used]
- [Integrations that worked smoothly]

### Challenges Overcome
- [Errors encountered and how resolved]
- [Workarounds developed]
- [Edge cases handled]

### New Patterns Discovered
- [Novel approaches to problems]
- [Optimization techniques found]
- [Reusable code created]

### Knowledge to Preserve
- [Key learnings to remember]
- [Context-specific solutions]
- [Client/project-specific adaptations]

### Recommendations for Future
- [Improvements to suggest]
- [Patterns to apply elsewhere]
- [Automation opportunities identified]
```

### 6. Pattern Application

When starting new construction tasks:

```python
def suggest_approaches(task_context: dict) -> list:
    """Suggest learned approaches for new tasks"""

    pipeline = ConstructionLearningPipeline('knowledge_base/')
    relevant = pipeline.apply_learnings(task_context)

    suggestions = []
    for item in relevant[:5]:  # Top 5 suggestions
        pattern = item['pattern']
        suggestions.append({
            'name': pattern['name'],
            'relevance': f"{item['relevance']*100:.0f}%",
            'summary': pattern['solution'][:200],
            'confidence': pattern['confidence'],
            'previous_uses': pattern.get('usage_count', 0)
        })

    return suggestions
```

## Integration with Other Skills

This skill works with:
- **verification-loop-construction**: Learn from verification failures
- **security-review-construction**: Capture security patterns
- **estimation skills**: Build estimation knowledge base
- **integration skills**: Capture API patterns

## Usage Commands

```bash
# Extract learnings from current session
/learn

# View patterns for current context
/suggest-patterns

# Add manual pattern
/add-pattern --category estimation --name "my_pattern"

# Export knowledge base
/export-kb --format yaml
```

---

**Every session is an opportunity to learn. Capture knowledge to compound expertise over time.**

© datadrivenconstruction · MIT · datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction

Похожие скиллы

Все скиллы по теме «Тесты и QA» →
continuous-learning affaan-m Скилл continuous-learning для Claude Code оценивает завершённые диалоги и извлекает шаблоны решений. Хук сохраняет найденные правила в каталог learned skills. CX Codex +1 6 300установок golang-continuous-integration samber Скилл golang-continuous-integration для Claude Code создаёт и правит GitHub Actions для Go: тесты, линтер, сканы безопасности и релизы. Закрывает пробелы в CI или собирает его с нуля. CX Codex +1 41 500установок event-continuous-improvement Samuel Berthe Скилл event-continuous-improvement находит повторяющиеся проблемы в отчётах прошлых конференций и превращает их в журнал улучшений. Помогает сохранить опыт при смене команды организаторов. CX Codex +1 6 600установок continuous-agent-loop affaan-m Скилл continuous-agent-loop для Claude Code задаёт схему автономного цикла агента: выбор режима, контроль качества, прогон evals и выход из сбоев. Держит агент на ходу без ручного присмотра. CX Codex +1 6 300установок continuous-discovery wondelai Скилл continuous-discovery помогает наладить еженедельные интервью с клиентами, построить Opportunity Solution Tree и проверять гипотезы силами продуктового трио. CX Codex +1 5 600установок continuous-loops dylantarre Скилл continuous-loops для Claude Code учит агента создавать зацикленные CSS-анимации по принципам классической мультипликации. Создаёт анимации для лоадеров, пульсаций, шиммеров и фоновых эффектов. CX Codex +1 569установок

Из того же набора156

Весь набор →
data-quality-check Скилл data-quality-check автоматически оценивает качество строительных данных по пяти метрикам: полнота, точность, согласованность, своевременность и достоверность. Нужен Python 3. CX Codex +1 118установок labor-productivity-analyzer Скилл labor-productivity-analyzer для Claude Code анализирует выработку по специальности, виду работ и месту на объекте. Он подключается к задачам учёта часов, объёмов и целевых показателей. CX Codex +1 118установок site-logistics-optimization Скилл site-logistics-optimization оптимизирует логистику строительной площадки: расписание доставок материалов, позиционирование кранов, распределение складских зон и движение техники. CX Codex +1 118установок data-source-audit Скилл data-source-audit разбирает системы, из которых проект получает данные: находит изолированные инструменты, домены без мастер-источника и собирает план интеграций. CX Codex +1 118установок cwicr-schedule-integrator Скилл cwicr-schedule-integrator связывает расценки CWICR с календарным графиком: считает бюджет активностей, раскладывает его по дням и строит денежный поток с метриками освоенного объёма. CX Codex +1 118установок data-evolution-analysis Скилл data-evolution-analysis оценивает цифровую зрелость строительной компании по методике DDC от бумажного документооборота до предиктивной аналитики. Помогает составить дорожную карту цифровизации. CX Codex +1 118установок semantic-search-cwicr Скилл semantic-search-cwicr находит похожие позиции в строительных расценках DDC CWICR через векторный поиск на естественном языке. Работает с 8 национальными базами в 26 языках. CX Codex +1 118установок cwicr-risk-calculator Скилл cwicr-risk-calculator рассчитывает сметные риски и надбавки на непредвиденные расходы в строительстве с помощью симуляций Монте-Карло. CX Codex +1 118установок

Спонсоры проекта

Компании, которые помогают держать аналитику открытой