Getting it into your agent
One page per mod, every tool's command on it. A separate URL per tool would split the same page into five that compete with each other.
npx skills add jdmorag97-rgb/DDC_Skills_for_AI_Agents_in_Construction --skill ids-checkergit clone --depth 1 https://github.com/jdmorag97-rgb/DDC_Skills_for_AI_Agents_in_ConstructionWrote this? Show the measurements
A badge with what this costs and how it scanned, read live from this page, so it follows the numbers instead of freezing them. Markdown for a README, HTML for a documentation site or a project page.
[](https://agentmods.dev/skills/jdmorag97-rgb/ddc_skills_for_ai_agents_in_construction/ids-checker)<a href="https://agentmods.dev/skills/jdmorag97-rgb/ddc_skills_for_ai_agents_in_construction/ids-checker"><img src="https://agentmods.dev/badge/skills/jdmorag97-rgb/ddc_skills_for_ai_agents_in_construction/ids-checker/github.svg" alt="Measured on agentmods" height="20"></a>Or the 80×15 button, for a site that already has a row of RSS and ATOM ones. Only the verdict fits; the numbers stay here.
<a href="https://agentmods.dev/skills/jdmorag97-rgb/ddc_skills_for_ai_agents_in_construction/ids-checker"><img src="https://agentmods.dev/badge/skills/jdmorag97-rgb/ddc_skills_for_ai_agents_in_construction/ids-checker.svg" alt="Reviewed on agentmods" width="80" height="20"></a>What it costs to keep this loaded
Counted locally with the o200k_base tokenizer, which is exact for GPT models; Claude uses its own tokenizer and its counts differ. Treat this as one consistent yardstick across the catalogue rather than a bill. Prices are per million input tokens.
| Model | Per session | Once invoked |
|---|---|---|
| Fable 5.1 | $0.00021 | $0.03791 |
| Opus 5 | $0.00010 | $0.01895 |
| Sonnet 5 | $0.00004 | $0.00758 |
| Haiku 4.5 | $0.00002 | $0.00379 |
Grade A, and why
ids-checker scanned grade A with 0 findings against 26 rules in 11 categories — prompt injection, anti-refusal, data exfiltration, privilege escalation, supply chain, agent snooping, system-prompt leakage, SSRF and excessive agency — measured 9d ago.
A static scan of the body, not an audit. Every finding is printed with the line that produced it so you can judge whether it matters here. A mod is markdown that instructs an agent; that is exactly why what it instructs is worth reading.
Nothing flagged
None of the 26 patterns this scan looks for appear in this file: no shell pipes, no recursive deletes, no credential paths, no hidden text, no instruction-override or anti-refusal phrasing, no agent-config snooping. That is not a guarantee, it is the absence of the things that are checkable.
This is a copy
100% identical to ids-checker — 0 lines differ, which has more behind it and is treated as the original. This page carries a canonical link to it rather than competing with it.
How it starts
The opening of the file, as written. The whole thing — 511 lines — stays where its author put it; the contents beside it link to each section on GitHub.
IDS Checker
Business Case
Problem Statement
BIM data validation challenges:
- Inconsistent model information
- Missing required properties
- Non-compliant data deliveries
- Manual validation is time-consuming
Solution
Automated IDS (Information Delivery Specification) checking system to validate BIM models against defined requirements.
Technical Implementation
import pandas as pd
from typing import Dict, Any, List, Optional
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
import re
class RequirementType(Enum):
PROPERTY = "property"
CLASSIFICATION = "classification"
MATERIAL = "material"
ATTRIBUTE = "attribute"
RELATION = "relation"
class Facet(Enum):
ENTITY = "entity"
PROPERTY_SET = "property_set"
PROPERTY = "property"
CLASSIFICATION = "classification"
MATERIAL = "material"
PART_OF = "part_of"
class Cardinality(Enum):
REQUIRED = "required"
OPTIONAL = "optional"
PROHIBITED = "prohibited"
class CheckResult(Enum):
PASS = "pass"
FAIL = "fail"
WARNING = "warning"
NOT_APPLICABLE = "n/a"
@dataclass
class IDSRequirement:
req_id: str
name: str
description: str
applicability: Dict[str, Any] # Which elements this applies to
requirements: List[Dict[str, Any]] # What is required
cardinality: Cardinality = Cardinality.REQUIRED
@dataclass
class ValidationResult:
element_id: str
element_type: str
requirement_id: str
result: CheckResult
message: str
details: Dict[str, Any] = field(default_factory=dict)
@dataclass
class IDSSpecification:
spec_id: str
name: str
version: str
purpose: str
requirements: List[IDSRequirement] = field(default_factory=list)
class IDSChecker:
"""Check BIM data against IDS (Information Delivery Specification)."""
def __init__(self, spec_name: str):
self.spec_name = spec_name
self.specifications: Dict[str, IDSSpecification] = {}
self.results: List[ValidationResult] = []
def create_specification(self, spec_id: str, name: str,
version: str = "1.0", purpose: str = "") -> IDSSpecification:
"""Create new IDS specification."""
spec = IDSSpecification(
spec_id=spec_id,
name=name,
version=version,
purpose=purpose
)
self.specifications[spec_id] = spec
return spec
def add_requirement(self, spec_id: str, requirement: IDSRequirement):
"""Add requirement to specification."""
if spec_id in self.specifications:
self.specifications[spec_id].requirements.append(requirement)
def add_property_requirement(self, spec_id: str, req_id: str, name: str,
entity_type: str, property_set: str,
property_name: str, data_type: str = None,
value_pattern: str = None,
cardinality: Cardinality = Cardinality.REQUIRED):
"""Add property requirement."""
requirement = IDSRequirement(
req_id=req_id,
name=name,
description=f"Property {property_name} in {property_set}",
applicability={'entity': entity_type},
requirements=[{
'type': RequirementType.PROPERTY.value,
'property_set': property_set,
'property_name': property_name,
'data_type': data_type,
'value_pattern': value_pattern
}],
cardinality=cardinality
)
self.add_requirement(spec_id, requirement)
def add_classification_requirement(self, spec_id: str, req_id: str, name: str,
entity_type: str, system: str,
value_pattern: str = None,
cardinality: Cardinality = Cardinality.REQUIRED):
"""Add classification requirement."""
requirement = IDSRequirement(
req_id=req_id,
name=name,
description=f"Classification from {system}",
applicability={'entity': entity_type},
requirements=[{
'type': RequirementType.CLASSIFICATION.value,
'system': system,
'value_pattern': value_pattern
}],
cardinality=cardinality
)
self.add_requirement(spec_id, requirement)
def create_standard_cobie_spec(self) -> str:
"""Create standard COBie specification."""
spec = self.create_specification(
"COBIE_BASIC",
"COBie Basic Requirements",
"1.0",
"Basic COBie data requirements for facility handover"
)
# Space requirements
self.add_property_requirement("COBIE_BASIC", "CB-SP-01", "Space Name",
"IfcSpace", "Pset_SpaceCommon", "Name")
self.add_property_requirement("COBIE_BASIC", "CB-SP-02", "Space Number",
"IfcSpace", "COBie_Space", "SpaceNumber")
self.add_property_requirement("COBIE_BASIC", "CB-SP-03", "Room Tag",
"IfcSpace", "COBie_Space", "RoomTag")
# Component requirements
self.add_property_requirement("COBIE_BASIC", "CB-CO-01", "Component Name",
"IfcElement", "COBie_Component", "Name")
self.add_property_requirement("COBIE_BASIC", "CB-CO-02", "Component Type",
"IfcElement", "COBie_Component", "TypeName")
self.add_property_requirement("COBIE_BASIC", "CB-CO-03", "Serial Number",
"IfcElement", "COBie_Component", "SerialNumber",
cardinality=Cardinality.OPTIONAL)
# Type requirements
self.add_property_requirement("COBIE_BASIC", "CB-TY-01", "Type Name",
"IfcTypeObject", "COBie_Type", "Name")
self.add_property_requirement("COBIE_BASIC", "CB-TY-02", "Manufacturer",
"IfcTypeObject", "COBie_Type", "Manufacturer")
self.add_property_requirement("COBIE_BASIC", "CB-TY-03", "Model Number",
"IfcTypeObject", "COBie_Type", "ModelNumber")
return "COBIE_BASIC"
def create_standard_lod_spec(self, lod_level: int = 300) -> str:
"""Create standard LOD specification."""
spec_id = f"LOD_{lod_level}"
spec = self.create_specification(
spec_id,
f"LOD {lod_level} Requirements",
"1.0",
f"Level of Development {lod_level} requirements"
)
if lod_level >= 200:
self.add_property_requirement(spec_id, f"LOD-{lod_level}-01",
"Element must have type",
"IfcElement", "Pset_ElementCommon", "Type")
if lod_level >= 300:
self.add_property_requirement(spec_id, f"LOD-{lod_level}-02",
"Element must have dimensions",
"IfcElement", "BaseQuantities", "Length")
self.add_property_requirement(spec_id, f"LOD-{lod_level}-03",
"Material assignment",
"IfcElement", "Pset_MaterialCommon", "Material")
if lod_level >= 350:
self.add_property_requirement(spec_id, f"LOD-{lod_level}-04",
"Fire rating",
"IfcElement", "Pset_ElementCommon", "FireRating",
cardinality=Cardinality.OPTIONAL)
self.add_classification_requirement(spec_id, f"LOD-{lod_level}-05",
"Uniformat classification",
"IfcElement", "Uniformat")
return spec_id
def check_element(self, element: Dict[str, Any],
spec_id: str) -> List[ValidationResult]:
"""Check single element against specification."""
results = []
if spec_id not in self.specifications:
return results
spec = self.specifications[spec_id]
for req in spec.requirements:
# Check applicability
if not self._matches_applicability(element, req.applicability):
continue
# Check requirements
for req_def in req.requirements:
result = self._check_requirement(element, req, req_def)
results.append(result)
return results
def _matches_applicability(self, element: Dict[str, Any],
applicability: Dict[str, Any]) -> bool:
"""Check if element matches applicability criteria."""
entity_filter = applicability.get('entity')
if entity_filter:
element_type = element.get('type', '')
if entity_filter not in element_type:
return False
return True
def _check_requirement(self, element: Dict[str, Any],
req: IDSRequirement,
req_def: Dict[str, Any]) -> ValidationResult:
"""Check single requirement."""
req_type = req_def.get('type')
if req_type == RequirementType.PROPERTY.value:
return self._check_property_requirement(element, req, req_def)
elif req_type == RequirementType.CLASSIFICATION.value:
return self._check_classification_requirement(element, req, req_def)
return ValidationResult(
element_id=element.get('id', ''),
element_type=element.get('type', ''),
requirement_id=req.req_id,
result=CheckResult.NOT_APPLICABLE,
message="Unknown requirement type"
)
def _check_property_requirement(self, element: Dict[str, Any],
req: IDSRequirement,
req_def: Dict[str, Any]) -> ValidationResult:
"""Check property requirement."""
pset_name = req_def.get('property_set')
prop_name = req_def.get('property_name')
value_pattern = req_def.get('value_pattern')
# Get property value
properties = element.get('properties', {})
pset = properties.get(pset_name, {})
value = pset.get(prop_name)
result = ValidationResult(
element_id=element.get('id', ''),
element_type=element.get('type', ''),
requirement_id=req.req_id,
result=CheckResult.PASS,
message="",
details={'property_set': pset_name, 'property': prop_name, 'value': value}
)
# Check if property exists
if value is None:
if req.cardinality == Cardinality.REQUIRED:
result.result = CheckResult.FAIL
result.message = f"Missing required property: {pset_name}.{prop_name}"
elif req.cardinality == Cardinality.PROHIBITED:
result.result = CheckResult.PASS
result.message = "Prohibited property correctly absent"
else:
result.result = CheckResult.WARNING
result.message = f"Optional property missing: {pset_name}.{prop_name}"
return result
# Check if property should not exist
if req.cardinality == Cardinality.PROHIBITED:
result.result = CheckResult.FAIL
result.message = f"Prohibited property exists: {pset_name}.{prop_name}"
return result
# Check value pattern
if value_pattern:
if not re.match(value_pattern, str(value)):
result.result = CheckResult.FAIL
result.message = f"Value '{value}' does not match pattern '{value_pattern}'"
return result
result.message = f"Property {prop_name} = {value}"
return result
def _check_classification_requirement(self, element: Dict[str, Any],
req: IDSRequirement,
req_def: Dict[str, Any]) -> ValidationResult:
"""Check classification requirement."""
system = req_def.get('system')
value_pattern = req_def.get('value_pattern')
classifications = element.get('classifications', {})
value = classifications.get(system)
result = ValidationResult(
element_id=element.get('id', ''),
element_type=element.get('type', ''),
requirement_id=req.req_id,
result=CheckResult.PASS,
message="",
details={'system': system, 'value': value}
)
if value is None:
if req.cardinality == Cardinality.REQUIRED:
result.result = CheckResult.FAIL
result.message = f"Missing classification: {system}"
else:
result.result = CheckResult.WARNING
result.message = f"Optional classification missing: {system}"
return result
if value_pattern and not re.match(value_pattern, str(value)):
result.result = CheckResult.FAIL
result.message = f"Classification '{value}' does not match pattern"
return result
result.message = f"Classification {system} = {value}"
return result
def check_model(self, elements: List[Dict[str, Any]],
spec_id: str) -> Dict[str, Any]:
"""Check all elements against specification."""
self.results = []
for element in elements:
element_results = self.check_element(element, spec_id)
self.results.extend(element_results)
# Summarize results
pass_count = sum(1 for r in self.results if r.result == CheckResult.PASS)
fail_count = sum(1 for r in self.results if r.result == CheckResult.FAIL)
warning_count = sum(1 for r in self.results if r.result == CheckResult.WARNING)
return {
'specification': spec_id,
'elements_checked': len(elements),
'total_checks': len(self.results),
'passed': pass_count,
'failed': fail_count,
'warnings': warning_count,
'compliance_rate': round(pass_count / len(self.results) * 100, 1) if self.results else 0,
'status': 'COMPLIANT' if fail_count == 0 else 'NON-COMPLIANT'
}
def get_failed_checks(self) -> List[Dict[str, Any]]:
"""Get list of failed checks."""
return [
{
'element_id': r.element_id,
'element_type': r.element_type,
'requirement': r.requirement_id,
'message': r.message,
'details': r.details
}
for r in self.results if r.result == CheckResult.FAIL
]
def export_to_excel(self, output_path: str) -> str:
"""Export validation results to Excel."""
with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
# Summary
summary = {
'Total Checks': len(self.results),
'Passed': sum(1 for r in self.results if r.result == CheckResult.PASS),
'Failed': sum(1 for r in self.results if r.result == CheckResult.FAIL),
'Warnings': sum(1 for r in self.results if r.result == CheckResult.WARNING)
}
summary_df = pd.DataFrame([summary])
summary_df.to_excel(writer, sheet_name='Summary', index=False)
# All results
results_df = pd.DataFrame([{
'Element ID': r.element_id,
'Element Type': r.element_type,
'Requirement': r.requirement_id,
'Result': r.result.value,
'Message': r.message
} for r in self.results])
results_df.to_excel(writer, sheet_name='All Results', index=False)
# Failed only
failed_df = pd.DataFrame(self.get_failed_checks())
if not failed_df.empty:
failed_df.to_excel(writer, sheet_name='Failed', index=False)
return output_path
What ships with it
2 files beside SKILL.md in the same directory: the scripts, references and assets a skill reads on demand. Not counted in the per-session cost; read them before you install if any of them is executable.
What this file has done since we first saw it
Hashed on every crawl. A supply-chain change to an agent config is a question of when, not whether, so the history is kept rather than the latest state alone.
- 9d ago First seen · 511 lines · 21 tokens per session scan A 34234406b877
ids-checker is a skill published in the GitHub repository jdmorag97-rgb/DDC_Skills_for_AI_Agents_in_Construction (2 stars, last pushed 6mo ago), licensed MIT. It adds 21 tokens to every session and 3,791 once invoked, about $0.0001 per session on Opus 5. A static security scan graded it A with 0 findings. It is 100% identical to ids-checker, differing in 0 lines, and is treated as a copy.
Other skills, from other repositories
qa-test-planner
Generate comprehensive test plans, manual test cases, regression test suites, and bug reports for QA engineers. Includes Figma MCP integration for design validation.
design-qa
Internal prototype QA helper. Use only after a Product Design prototype, URL-to-code build, or image-to-code build has a source visual target and a rendered implementation to compare before handoff. Do not use for broad UX critique, design critique, product audits, or flow reviews; route those user-facing requests to…
health
Runs a budget-aware agent-assisted engineering health audit for instruction/config drift, hooks/MCP, verifier surfaces, and AI maintainability. Use when users ask in any language to audit Claude, Codex, Pi, agent instructions, MCP or hooks, verifier coverage, or AI-maintainability drift. Not for debugging application…
hunt
Finds root cause before applying fixes for errors, crashes, regressions, failing tests, broken behavior, and screenshot-reported defects. Use when users report in any language errors, crashes, broken behavior, regressions, failing tests, screenshot evidence, or something that used to work and now fails. Not for code…
chrome-cdp
Drive a headless Chrome over the Chrome DevTools Protocol (CDP) for browser QA — navigate, click, fill forms, read the DOM/accessibility tree, screenshot, and assert. Use whenever a task requires loading a web page and interacting with it like a user. Chrome is launched by a bash step (recipe below); this skill…
ui-craft-checks
Use this comprehensive gate for formal review, QA, launch handoff, exact-fidelity inspection, high-risk complex UI, or when the fast gate exposes a deeper craft problem. Ordinary single-screen work uses ui-design-executor and its bundled validator without loading this full matrix. Pair standalone artifacts with…