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 datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction --skill ids-checkergit clone --depth 1 https://github.com/datadrivenconstruction/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/datadrivenconstruction/ddc_skills_for_ai_agents_in_construction/ids-checker)<a href="https://agentmods.dev/skills/datadrivenconstruction/ddc_skills_for_ai_agents_in_construction/ids-checker"><img src="https://agentmods.dev/badge/skills/datadrivenconstruction/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/datadrivenconstruction/ddc_skills_for_ai_agents_in_construction/ids-checker"><img src="https://agentmods.dev/badge/skills/datadrivenconstruction/ddc_skills_for_ai_agents_in_construction/ids-checker.svg" alt="Reviewed on agentmods" width="80" height="20"></a>- NVIDIA SkillSpector pass
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.5 | $0.00008 | $0.01516 |
| Sonnet 5.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 1mo 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.
Copies of this mod
1 near-identical copy found in the catalogue:
- ids-checker — 100% identical, 0 lines differ
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.
- 1mo ago First seen · 511 lines · 21 tokens per session scan A 34234406b877
ids-checker is a skill published in the GitHub repository datadrivenconstruction/DDC_Skills_for_AI_Agents_in_Construction (374 stars, last pushed 8d ago), licensed MIT. It adds 21 tokens to every session and 3,791 once invoked, about $0.0001 per session on Opus 5.5. A static security scan graded it A with 0 findings. No closer match exists in the catalogue, so it is treated as the original; first seen 2026-09-03.
Other skills, from other repositories
log-analyzer
A log-analysis helper that reads application and system logs to find unusual patterns and likely causes. Logs are records of events such as errors, requests, warnings, and service activity.
shiny-py-optimize
Diagnose and fix performance problems in Shiny for Python apps — slow startup, sluggish interactions, blocking operations, and apps that struggle beyond a handful of concurrent users. Use when a Shiny for Python app is slow, hangs, recomputes too much, times out, or must support more users; when the user asks to…
code-review-web
Review web application code for bugs, security issues, performance problems, and stack-specific anti-patterns. Use this skill whenever the user wants to review code, debug a production issue, investigate a build failure, audit security, or check a PR before merging. Triggers on code review, review my code, debug…
mcp-maintainer
Operate and maintain the local MCP server for this repository. Use for MCP tool updates, policy-guard changes, host configuration, and MCP runtime troubleshooting.
022-root-cause-analysis
Use when a framed problem needs root-cause investigation rather than a symptom-level fix, applying Five Whys, Fishbone (Ishikawa), Current Reality Tree, and constraint identification. This should trigger when an issue's Root Cause Analysis point of view needs evaluation, or when a maintainer directly asks to find the…
126-java-exception-handling
Use when you need to apply Java exception handling best practices — including using specific exception types, managing resources with try-with-resources, securing exception messages, preserving error context via exception chaining, validating inputs early with fail-fast principles, handling thread interruption…