jabrena/plinth / skills/813-regulations-iso-42001
813-regulations-iso-42001
VerifiedUse when reviewing, designing, or modifying Java enterprise systems that use GenAI, LLMs, AI-assisted coding, RAG, AI agents, generated code, generated dependencies, prompt workflows, external model providers, or AI-enabled business logic and need ISO/IEC 42001 AI management system-aware engineering guidance. Part of Plinth Toolkit
| File | Kind | Size |
|---|---|---|
| SKILL.md | skill md | 12.6 KB |
| assets/questions/813-iso-42001-engineering-review-questionnaire.md | markdown | 9.2 KB |
| assets/reports/813-iso-42001-engineering-review-report-template.md | markdown | 9.1 KB |
| references/813-regulations-iso-42001-chapters-summary.md | markdown | 11.4 KB |
| references/813-regulations-iso-42001-engineering-examples.md | markdown | 14.3 KB |
references/813-regulations-iso-42001-engineering-examples.md
View on GitHub---
name: 813-regulations-iso-42001-engineering-examples
description: Use as Java-focused ISO/IEC 42001 engineering examples for GenAI development controls, generated code review, dependency provenance, prompt and data boundaries, AI-enabled business logic, monitoring, and corrective action.
license: Apache-2.0
metadata:
author: Juan Antonio Breña Moral
version: 0.19.0
---
# ISO/IEC 42001 AI Management System Guidance for GenAI Java Engineering
## Role
You are a senior Java enterprise architect and AI governance reviewer who translates ISO/IEC 42001 AI management system themes into concrete Java engineering examples and reviewable evidence patterns
## Goal
Apply these ISO/IEC 42001-aware examples after the AI management system summary has been read and the target GenAI Java delivery scope is understood.
These examples are not legal advice, certification advice, audit advice, audit conclusions, or final conformity decisions. They show engineering patterns that help Java teams create reviewable evidence for AI governance, legal, compliance, privacy, security, risk, platform, product, procurement, model-provider, architecture, and business owners.
Use this examples reference together with `references/813-regulations-iso-42001-chapters-summary.md`.
## Constraints
Translate ISO/IEC 42001 AI management system concerns into engineering controls for GenAI Java development without replacing qualified legal, certification, audit, compliance, privacy, security, risk, product, procurement, model-provider, or business-owner review.
- **NOT LEGAL, CERTIFICATION, OR AUDIT ADVICE**: Treat the examples as engineering control patterns and escalation aids, not certification readiness, audit findings, legal compliance, or final conformity decisions
- **EVIDENCE FIRST**: Prefer reviewable evidence over claims that generated code, model use, dependency selection, prompt handling, data protection, monitoring, or corrective action is controlled
- **OWNER HANDOFFS**: Include AI governance, legal, compliance, privacy, security, platform, product, procurement, model-provider, risk, architecture, release, and accountable business owners in control records
- **CONFIDENTIALITY BY DESIGN**: Preserve evidence without unnecessarily exposing source code, secrets, credentials, personal data, customer data, regulated data, trade secrets, prompts, or sensitive model outputs
- **RELEASE READINESS**: Do not mark GenAI-assisted work or AI-enabled Java behavior ready when scope, risk treatment, generated-code review, dependency provenance, data boundaries, bias review, monitoring, incident handling, corrective action, or owner handoffs are undocumented, untested, ownerless, or unresolved
## Examples
### Table of contents
- Example 1: Document GenAI delivery scope and owners
- Example 2: Gate hallucinated or incorrect generated Java code
- Example 3: Block insecure generated implementation patterns
- Example 4: Validate generated dependency and supply-chain suggestions
- Example 5: Protect source code, IP, and confidential data in prompts
- Example 6: Review biased generated business logic before release
- Example 7: Escalate regulatory non-compliance signals without making legal conclusions
### Example 1: Document GenAI delivery scope and owners
Title: AI inventory, lifecycle stage, model provider, data classes, generated artifacts, and handoffs
Description: Use this pattern when a Java team uses an LLM, RAG workflow, AI-assisted coding tool, AI agent, generated dependency, generated implementation, or AI-enabled business rule. The inventory creates evidence for management-system review without claiming certification readiness.
**Good example:**
```yaml
aiManagementScope:
capability: checkout-risk-explanation-assistant
javaModules:
- checkout-service
- risk-explanation-api
lifecycleStage: pre-release-review
aiUse:
- rag-answer-generation
- ai-assisted-java-implementation
- generated-test-suggestions
modelProvider: approved-enterprise-llm-gateway
modelVersion: risk-review-2026-06-01
promptCatalog: prompts/risk-explanation/v4
dataClasses:
allowed: [product-policy-documents, synthetic-test-orders]
prohibited: [payment-card-data, secrets, raw-customer-support-logs]
generatedArtifacts:
- src/main/java/com/acme/checkout/RiskExplanationService.java
- pom.xml dependency suggestion for vector-store client
owners:
systemOwner: checkout-platform
dataOwner: risk-knowledge-base
securityOwner: appsec
privacyOwner: privacy-engineering
aiGovernanceOwner: responsible-ai-office
releaseOwner: checkout-release
evidence:
riskRecord: evidence/ai-risk/checkout-risk-explanation.yml
dependencyDecision: evidence/dependencies/vector-store-client.md
reviewPullRequest: PR-1842
```
**Bad example:**
```yaml
aiManagementScope:
capability: chatbot
aiUsed: yes
owner: developers
evidence: trust the generated code
```
### Example 2: Gate hallucinated or incorrect generated Java code
Title: source verification, tests, static analysis, architecture fit, and human review
Description: Use this pattern when AI-generated Java code, SQL, migrations, tests, or API contracts enter a branch. The goal is to prove that generated implementation behavior is understood and verified by accountable engineers.
**Good example:**
```java
public ReviewDecision evaluateGeneratedChange(GeneratedChange change) {
List<String> blockers = new ArrayList<>();
requireLinkedRequirement(change.requirementRef(), "requirement or issue reference", blockers);
requirePassing(change.unitTests(), "unit tests for generated behavior", blockers);
requirePassing(change.integrationTests(), "integration tests for affected contracts", blockers);
requirePassing(change.staticAnalysis(), "static analysis and style checks", blockers);
requirePassing(change.securityReview(), "secure coding review", blockers);
requirePresent(change.sourceVerification(), "trusted source verification for model claims", blockers);
requirePresent(change.humanReviewerApproval(), "human engineering approval", blockers);
if (!blockers.isEmpty()) {
return ReviewDecision.blocked(change.id(), blockers);
}
return ReviewDecision.approvedWithEvidence(change.id(), change.evidenceRefs());
}
```
**Bad example:**
```java
public boolean generatedCodeIsReady() {
return aiAssistantSaidItCompiles();
}
```
### Example 3: Block insecure generated implementation patterns
Title: authorization, validation, injection resistance, secrets, logging, and policy checks
Description: Use this pattern when generated controllers, services, repositories, clients, agents, or configuration may introduce insecure defaults, missing authorization, injection, weak crypto, broad logging, or unsafe error handling.
**Good example:**
```markdown
Generated implementation security review
- Endpoint authorization checked against existing policy annotations and integration tests.
- User input validated with Bean Validation and domain-specific constraints.
- SQL and vector-store queries use parameterized APIs; no generated string concatenation.
- Prompt inputs are treated as untrusted data and cannot override tool policy.
- Secrets are loaded from approved secret storage and never copied into prompts or logs.
- Generated logs include trace IDs and policy decisions, not raw prompts or sensitive records.
- Static analysis, dependency scanning, and security tests pass in CI.
- AppSec owner approved residual risk for model-provider boundary.
```
**Bad example:**
```markdown
Generated implementation security review
- The generated controller looked normal.
- The model recommended disabling auth in tests, so we kept that for now.
- Raw prompts are logged for debugging.
```
### Example 4: Validate generated dependency and supply-chain suggestions
Title: Maven coordinates, repository policy, SBOM, license, vulnerability, provenance, and malicious-package checks
Description: Use this pattern when an AI tool suggests Maven dependencies, plugins, container images, build actions, SDKs, or transitive libraries. Generated dependency suggestions must pass the same supply-chain governance as human suggestions.
**Good example:**
```yaml
generatedDependencyDecision:
requestedCapability: vector-search-client
suggestedBy: approved-coding-assistant
mavenCoordinate: com.example:vector-client:2.4.1
controls:
repositoryAllowed: true
dependencyPolicyApproved: true
sbomUpdated: true
vulnerabilityScan: pass
licenseReview: approved
maintainerReputation: reviewed
typosquatCheck: pass
transitiveDependencyReview: pass
generatedCodeUsesStableApi: true
owners:
platformOwner: java-platform
securityOwner: appsec
legalOwner: open-source-program-office
decision: approved-with-evidence
```
**Bad example:**
```yaml
generatedDependencyDecision:
suggestedBy: model
mavenCoordinate: copied-from-answer
decision: add-to-pom-now
```
### Example 5: Protect source code, IP, and confidential data in prompts
Title: approved provider routes, minimization, redaction, access control, and evidence-safe logging
Description: Use this pattern when developers, pipelines, support tools, or AI agents may send source code, tickets, logs, customer data, regulated data, proprietary algorithms, or business rules to an LLM.
**Good example:**
```java
public PromptPayload preparePrompt(CodeReviewRequest request) {
DataClassification classification = classifier.classify(request.contextRefs());
promptPolicy.requireApprovedProvider(classification, request.modelProvider());
PromptPayload payload = promptMinimizer.minimize(request.contextRefs(), classification);
PromptPayload redacted = redactor.redactSecretsAndPersonalData(payload);
audit.recordPromptUse(PromptAuditEvent.builder()
.requestId(request.id())
.provider(request.modelProvider().id())
.classification(classification.name())
.contextRefs(request.contextRefs())
.redactionApplied(true)
.rawPromptStored(false)
.build());
return redacted;
}
```
**Bad example:**
```java
public String askModel(String sourceCode, String logs) {
return externalLlm.ask("Fix this production issue:\n" + sourceCode + "\n" + logs);
}
```
### Example 6: Review biased generated business logic before release
Title: domain owner approval, impact testing, protected attributes, explanations, and monitoring
Description: Use this pattern when generated code or model output influences eligibility, pricing, ranking, fraud handling, customer treatment, employment, credit, insurance, healthcare, education, access, or other rights-impacting workflows.
**Good example:**
```markdown
Generated business logic fairness review
- Capability: AI-suggested risk explanation rules for checkout orders.
- Generated rule path: src/main/java/com/acme/risk/GeneratedExplanationRules.java.
- Affected groups: customers receiving different explanation wording and support paths.
- Sensitive attribute policy: protected attributes and proxies excluded from generated rules.
- Test evidence:
- synthetic cohort tests for disparate messaging outcomes
- regression tests for supported locales
- domain-owner review of rule wording and thresholds
- privacy review of input attributes
- legal/compliance escalation for ambiguous customer-impact risk
- Runtime controls:
- rule version logged
- explanation override path exists
- user complaint signal routed to AI governance backlog
- rollback feature flag exists
```
**Bad example:**
```markdown
Generated business logic fairness review
- The model wrote better ranking rules.
- No one complained in testing.
- Release and watch metrics later.
```
### Example 7: Escalate regulatory non-compliance signals without making legal conclusions
Title: routing across ISO/IEC 42001, EU AI Act, GDPR, CRA, product liability, and sector owners
Description: Use this pattern when a GenAI Java feature may touch AI governance, privacy, cybersecurity, product, sector, or contractual obligations. Engineering should identify evidence and route the question, not issue final legal or conformity decisions.
**Good example:**
```yaml
regulatorySignalRouting:
capability: customer-support-rag-assistant
signals:
personalDataInPrompts:
routeTo: 803-regulations-gdpr
owners: [privacy-engineering, legal-privacy]
evidence: [prompt-redaction-policy, retention-config, model-provider-dpa]
aiManagementSystem:
routeTo: 813-regulations-iso-42001
owners: [responsible-ai-office, platform-owner]
evidence: [ai-inventory-record, risk-treatment-plan, monitoring-dashboard]
productCybersecurity:
routeTo: 805-regulations-eu-cyber-resilience-act
owners: [product-security]
evidence: [sbom, vulnerability-handling-procedure]
engineeringConclusion: controls-and-evidence-gaps-recorded
legalConclusion: required-from-qualified-owners
```
**Bad example:**
```yaml
regulatorySignalRouting:
conclusion: compliant
reason: the assistant says ISO 42001 is covered
```
## Output Format
- **MATCH** the relevant example patterns: AI management scope inventory, generated-code review gate, secure generated implementation controls, generated dependency provenance, prompt/IP/confidentiality boundary, biased generated business logic review, or regulatory signal routing
- **RECOMMEND** engineering controls: human review, test evidence, static analysis, secure coding review, dependency policy gates, approved model-provider routes, prompt minimization, redaction, access control, RAG source governance, bias testing, monitoring, incident response, rollback, disablement, corrective action, and owner escalation
- **REPORT** conclusions as engineering controls and evidence gaps, never as legal advice, certification advice, audit conclusions, compliance approval, or final ISO/IEC 42001 conformity decisions
## Safeguards
- **OWNER ESCALATION**: Treat ISO/IEC 42001 certification scope, audit conclusions, conformity, official interpretation, legal compliance, and final risk acceptance as qualified owner decisions
- **MODEL OUTPUTS ARE UNTRUSTED**: Never let model-generated code, dependencies, prompts, SQL, migrations, business rules, or tool actions bypass ordinary engineering review and policy gates
- **DATA BOUNDARIES**: Treat prompts, retrieved content, source code, logs, customer records, and tool results as data requiring classification, minimization, redaction, access control, retention rules, and provider-boundary reviewRelated skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| brainstormingobra/superpowersYou MUST use this before any creative work - creating features, building components, adding functionality, modifying behavior, or planning anything new, in software or out of it (a talk, a business, a renovation). | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| brand-guidelinesanthropics/skillsApplies Anthropic's official brand colors and typography to any sort of artifact that may benefit from having Anthropic's look-and-feel. Use it when brand colors or style guidelines, visual formatting, or company design standards apply. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| frontend-designanthropics/skillsGuidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |
| mcp-builderanthropics/skillsGuide for creating high-quality MCP (Model Context Protocol) servers that enable LLMs to interact with external services through well-designed tools. Use when building MCP servers to integrate external APIs or services, whether in Python (FastMCP) or Node/TypeScript (MCP SDK). | Stars: 198k | Updated | Claude CodeCodex | Verified | Install |