AI Skill Report Card

Integrating Project Configurations

B74·Nov 19, 2026·Source: Web
12 / 15

When opening/onboarding a project, run the 9-step discovery flow and produce a configuration map + report. Never invent tools, configs, or test results that weren't actually found/verified.

1. Scan project root and subdirectories
2. Detect config files (package.json, pyproject.toml, Cargo.toml, build.gradle, etc.)
3. Identify languages/frameworks from source files + manifests
4. Detect AI model/API references (search for provider keys, endpoints in configs)
5. Detect build tools, test runners, CI/CD pipeline files (.github/workflows, Jenkinsfile, etc.)
6. Build integration map (language -> toolchain -> pipeline -> platform)
7. Validate: do declared tools actually exist/run? (version check, dry-run)
8. Report gaps/conflicts to user, do NOT silently resolve destructive ones
9. Apply safe linking only after confirmation; back up original configs first
Recommendation▾
Add a third example showing a conflict/multi-platform scenario (e.g., overlapping config priority resolution in action) to strengthen example diversity.
14 / 15

Progress checklist for any project integration task:

  • Step 1: Scan filesystem for all config/manifest files (native formats: JSON/YAML/TOML/.env/language-specific)
  • Step 2: Parse and classify each config (build / test / deploy / model / secret-reference / platform)
  • Step 3: Detect languages, frameworks, dependency managers per the 25-language matrix (only mark "supported" after toolchain verification)
  • Step 4: Detect existing pipelines and map their stages (configure → deps → build → analyze → scan → test → package → deploy)
  • Step 5: Detect AI model/API declarations; separate key references from actual secret values
  • Step 6: Determine target platforms (Desktop/Mobile/Web/TV/Tablet) and platform-specific build requirements
  • Step 7: Apply configuration priority order to resolve any overlapping settings (see below)
  • Step 8: Validate end-to-end by running build/test commands non-destructively where possible
  • Step 9: Backup originals, then write central config with inheritance, never overwriting native project files
  • Step 10: Emit final report: linked / unsupported / conflicts / reasons

Configuration Priority (low → high precedence)

  1. System Defaults
  2. Global JEMINI-X Settings
  3. Project Settings
  4. Platform Settings
  5. Environment Variables / Secret References
  6. Runtime Overrides

Conflict rule: higher-precedence layer wins; log every override applied with source and reason.

Secret Handling

  • settings.json (or equivalent) stores only key references (e.g. API_KEY_REF: "OPENAI_API_KEY").
  • Actual secret values live in environment variables or a secret manager — never in project files, logs, or reports.
  • When printing diagnostics, redact any value matching known secret patterns.
Recommendation▾
Clarify what 'JEMINI-X Settings' refers to—this undefined proper noun appears without context and may confuse users unfamiliar with the system.

For each of the 25 target languages, define and verify before claiming support:

YAML
language: <name> compiler_or_interpreter: <path/version, verified: true/false> build_system: <tool, verified> package_manager: <tool, verified> formatter: <tool, verified> linter: <tool, verified> debugger: <tool, verified> language_server: <tool, verified> testing_tools: <tool(s), verified> security_analysis: <tool, verified> status: full | partial | unsupported unsupported_reason: <if applicable>

Mark status: full only when every field has verified: true from an actual successful probe (e.g., tool --version succeeded, a sample build/test ran).

JSON
{ "project": "example-app", "model_config": { "provider": "anthropic", "model_name": "claude-x", "api_endpoint": "https://api.provider.com/v1", "parameters": { "temperature": 0.2, "max_tokens": 4096 }, "api_key_ref": "ANTHROPIC_API_KEY", "fallback_model": "provider/backup-model", "request_limits": { "rpm": 60, "concurrent": 4 }, "timeout_ms": 30000 } }
13 / 20

Example 1: Input: Open a Node.js + React web project with a .github/workflows/ci.yml, no AI config. Output:

Discovered: package.json (npm), eslint, jest, webpack, .github/workflows/ci.yml (build→test→deploy)
Languages: JavaScript/TypeScript — status: full (npm, eslint, jest, tsc all verified)
Platform: Web
Model config: none found — no action taken, flagged as "not configured" (not an error)
Pipelines: CI workflow linked read-only, no stages modified
Report: 1 language fully integrated, 0 conflicts, 0 secrets exposed

Example 2: Input: Python backend with pyproject.toml declaring a provider key directly as plaintext in a committed config file. Output:

Discovered: pyproject.toml, poetry, pytest, mypy
Languages: Python — status: full
SECURITY FLAG: plaintext API key found in config/settings.toml
Action: did NOT remove or auto-rotate; reported to user with exact file/line,
recommended moving to env var + api_key_ref, awaiting confirmation before edit.
Recommendation▾
Show a concrete 'bad outcome' example (e.g., a case where Claude incorrectly claims full support or leaks a secret) to reinforce the pitfalls section with real input/output pairs.
  • Always diff-check before writing any merged config; keep .bak of originals.
  • Prefer additive inheritance (global → project → platform) over flattening/overwriting.
  • Treat "not found" and "not supported" as distinct states in reports — don't conflate.
  • Re-validate integrations after any dependency or toolchain version change.
  • Keep per-project configs isolated; never let one project's env/model config leak into another's context.
  • Claiming a language/tool is "supported" without actually running a verification probe.
  • Writing secret values (not references) into any tracked project file or log output.
  • Silently deleting or disabling an existing pipeline stage to "fix" a failure.
  • Overwriting a project's native config format (e.g., converting their YAML to JSON) without necessity.
  • Reporting fabricated build/test success instead of actual tool output.
  • Merging configs from two different projects due to similar naming or shared directory scans.
0
Grade BAI Skill Framework
Scorecard
Criteria Breakdown
Quick Start
12/15
Workflow
14/15
Examples
13/20
Completeness
16/20
Format
14/15
Conciseness
13/15