Generated from a live hackathon session — March 2026 Covers: what we built (PR #74), where we're going, and how to structure the work.

Context: We're evaluating pulling ironman-skills into Global MCP so developers get all internal tools (Harness, Jira, Confluence, GitHub, DockerHub, Artifactory) without managing any tokens themselves.

Every developer who wants to use ironman skills must:

1. Clone the repo

Date: 2026-03-30
Environment: staging.datarobot.com
Tools: execute_datarobot_api + search_datarobot_api (Global MCP code-mode tools)

• Clear project purpose: The opening line immediately tells me this is Pulumi IaC for DataRobot resources, and lists the specific resource types (agents, LLM blueprints, etc.)
• Explicit "do not modify" list: Calling out uv.lock, Pulumi.yaml, and .vscode/ prevents common mistakes
• Command reference with context: The commands section shows where to run commands from (project root) and what each does
• Critical constraints section: Auth requirements, plugin versioning, and rate limiting are clearly flagged as gotchas
• Resource naming convention: The {Component} {Type} pattern is explicit with an example
• Feature flag location: Clear that feature_flags/ contains YAML toggles for optional components

• Clear scope definition: The opening paragraph immediately establishes this is a shared library for filesystem abstractions, telemetry, and utilities used by three specific sub-projects.
• Explicit "do not modify" list: Calling out py.typed and task-common.yaml prevents accidental changes to infrastructure files.
• Concrete command reference: The commands section provides exact shell commands with clear descriptions of what each does.
• Downstream impact warning: The "Critical constraints" section explicitly warns that changes affect three dependent projects and emphasizes thorough testing.
• Post-modification workflow: Clear instruction to run dr task run install after modifying core to re-install all dependents.
• Import pattern specification: Explicitly states to use from core.module import X pattern.

• Clear role definition: The opening line immediately establishes this is a React frontend that talks to a FastAPI backend via REST and AG-UI streaming protocol.
• Explicit "Modify these" vs "Do NOT modify" sections: This is excellent for preventing accidental changes to config files or static assets.
• Command reference with context: Commands include the dr task run prefix and note they run from project root, preventing common path errors.
• Technology stack is explicit: React 19, Vite 7, TypeScript strict mode, Tailwind v4, Radix UI, shadcn/ui, Zustand, React Query — all clearly listed.
• Critical constraints section: Calling out AG-UI protocol compatibility, ESM-only, and MSW v2 helps avoid breaking changes.
• Convention for API calls: "Always through src/api/ — never raw fetch/axios in components" is clear and actionable.

• Clear purpose statement: The opening line immediately tells me this is a REST API backend that routes chat requests and implements AG-UI protocol streaming.
• Explicit "do not modify" list: Calling out migrations/env.py, static/, templates/, and alembic_migration.py prevents common mistakes.
• Command reference with context: All commands show they must be run from project root, and include the dr task run prefix consistently.
• Technology stack clarity: SQLModel, Pydantic v2, async/await, SSE streaming — I know what patterns to expect.
• Migration workflow: The two-step process for database changes is clearly documented with example commands.
• Critical constraints section: Calling out async DB limitations, required env vars, and mypy strict mode sets clear expectations.

1. Clear file modification boundaries — The "Modify these / Do NOT modify" structure immediately tells me where I can safely work vs. what's managed upstream. This is critical for avoiding wasted effort.

2. Concrete code examples — The tool/resource/prompt snippets with actual decorators (@dr_mcp_tool, @mcp.resource) give me copy-paste starting points rather than abstract descriptions.

3. Command reference is complete — All the dr task run mcp_server:* commands are listed with brief descriptions. I know how to install, test, lint, and run the server.

• Clear "Do NOT modify" warnings: The explicit callouts for llm() method, public/, docker_context/, and runtime infrastructure files are excellent. These are bolded and marked as CRITICAL, which would prevent a new agent from breaking deployment.

• Concrete code pattern: The implementation pattern section provides actual Python code showing class structure, required naming conventions, and method signatures. This is immediately actionable.

• Command reference with context: Commands are clearly listed with their purpose, and the note to run from project root is helpful. The post-deployment validation example is a nice touch.