10x-stack-assess

Detect stack components from project files and score agent-friendliness against four quality gates.

1|Updated Feb 26, 2025
One-click install
npx skills add https://github.com/kryptonum-dev/fabryka-atrakcji --skill 10x-stack-assess
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: 10x-stack-assess
Source: https://github.com/kryptonum-dev/fabryka-atrakcji/tree/main/.agents/skills/10x-stack-assess
Command: npx skills add https://github.com/kryptonum-dev/fabryka-atrakcji --skill 10x-stack-assess

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you evaluate how well an existing codebase supports AI agent workflows by checking whether key properties for safe, reliable automation are present and by documenting what to add when they are missing.

Core Features & Use Cases

  • Assesses agent-friendliness via four quality gates: type safety, convention-based structure, popularity within the language family, and documentation quality, producing a clear matrix-style assessment.
  • Detects stack components from your project files: reads real markers like package.json/tsconfig, pyproject.toml, Cargo.toml, go.mod, Gemfile, composer.json, and *.csproj to infer language, framework, build tooling, CI signals, and instruction-file presence.
  • Generates concrete compensation strategies: when a gate fails, it provides ready-to-paste instruction rules to add to AGENTS.md/related docs so an agent can operate effectively without replacing the stack.
  • Writes an actionable output file: creates context/foundation/stack-assessment.md (brownfield) for downstream health checks and planning.

Quick Start

Run the skill in your existing project directory to produce an evidence-based stack assessment and ready-to-paste instruction-file additions for any gaps it finds.

Frequently Asked Questions about 10x-stack-assess

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I evaluate if my existing codebase is ready for AI agent workflows?

Evaluating codebase readiness for AI agents involves checking stack components for type safety, convention-based structure, popularity, and documentation quality. This Skill detects markers from files like package.json and pyproject.toml to score agent-friendliness and generate compensation instructions for any gaps.

What makes a technology stack easy for AI coding agents to navigate and modify?

A technology stack is easy for AI agents to navigate when it uses typed code, follows convention-based structure, relies on popular language family frameworks, and maintains high documentation quality. These four properties enable reliable automated change execution across the codebase.

How can I add agent instructions to a brownfield project that lacks type safety or conventions?

You can add agent instructions to a brownfield project by generating ready-to-paste compensation rules for AGENTS.md. When a stack assessment detects missing type safety or conventions, it produces specific instruction-file additions so the agent can operate effectively without replacing the stack.

Can I assess agent workflow readiness for a Python or Rust project using existing build files?

Yes, you can assess agent workflow readiness for Python, Rust, Go, Ruby, PHP, and C# projects. The assessment reads real markers like pyproject.toml, Cargo.toml, go.mod, Gemfile, composer.json, and *.csproj to infer language, framework, and build tooling for scoring.

What is the best way to document gaps in my stack for AI-assisted coding?

The best way to document stack gaps for AI-assisted coding is to generate a structured matrix assessment with per-component scoring and gap analysis. This produces an actionable output file containing evidence-based compensation instructions for any missing agent-readiness properties.

Why does my AI agent struggle to make reliable changes in my existing codebase?

AI agents struggle to make reliable changes in existing codebases when the stack lacks type safety, convention-based structure, training-data popularity, or documentation quality. A brownfield stack assessment can identify these specific gaps and provide instruction rules to compensate.