How does project-awareness gather context?

It scans root files (e.g., package.json, tsconfig.json, Cargo.toml, go.mod, pyproject.toml, etc.) and typical directories using Read, Glob, and Grep to infer project type, scripts, and conventions.

Which files and directories are considered?

Key indicators include package.json, tsconfig.json, Cargo.toml, go.mod, pyproject.toml, setup.py, requirements.txt, Gemfile, pubspec.yaml, pom.xml, build.gradle, plus common layout dirs like src/, app/, lib/, tests/.

Is project-awareness always running in the background?

Yes. It is designed to be invoked automatically as background knowledge so you get contextual guidance without manual checks.

project-awareness

npx machina-cli add skill speson/not-my-reforge/project-awareness --openclaw

Files (1)

SKILL.md

2.0 KB

You have the project-awareness skill. When starting work on a project, automatically gather the following context before proceeding with any task.

Auto-Detection Checklist

1. Project Type

Check for these files to determine the tech stack:

package.json → Node.js (check for framework: next, remix, vite, etc.)
tsconfig.json → TypeScript
Cargo.toml → Rust
go.mod → Go
pyproject.toml / setup.py / requirements.txt → Python
Gemfile → Ruby
pubspec.yaml → Flutter/Dart
pom.xml / build.gradle → Java/Kotlin

2. Key Commands

Extract from package.json scripts, Makefile, or similar:

Dev: npm run dev, cargo run, go run .
Build: npm run build, cargo build, go build
Test: npm test, cargo test, go test ./...
Lint: npm run lint, cargo clippy

3. Directory Conventions

Map the source code layout:

src/ vs app/ vs lib/ — where does code live?
components/ — UI components
api/ or routes/ — API endpoints
utils/ or helpers/ — shared utilities
types/ or interfaces/ — type definitions
__tests__/ or tests/ — test files

4. Patterns to Follow

Detect from existing code:

Naming: camelCase vs snake_case vs kebab-case
Exports: named vs default
Imports: relative vs aliases (@/)
Error handling: try-catch vs Result types
State management: which library/pattern

Usage

This skill is automatically invoked as background knowledge. You don't need to run all checks every time — use judgment about which context is relevant to the current task. Prioritize reading:

The file(s) most relevant to the current task
Configuration files that affect the task
Related test files

Source

git clone https://github.com/speson/not-my-reforge/blob/main/skills/project-awareness/SKILL.mdView on GitHub

Overview

project-awareness automatically detects the project type, tech stack, conventions, and key files to provide background context for work. It identifies indicators like package.json, tsconfig.json, Cargo.toml, go.mod, and pyproject.toml to map structure, scripts, and tooling. This context helps tailor guidance to the repo’s layout and standards, reducing guesswork when you start a task.

How This Skill Works

It runs behind the scenes, scanning for standard files and directory names using Read, Glob, and Grep. It builds a mental model of the project: detected type, key scripts, common directories, and coding patterns. The resulting context informs task planning, code navigation, and decision-making without requiring manual setup.

When to Use It

When starting work on a new or unfamiliar project to quickly identify tech stack, scripts, and folder conventions
When exploring a legacy repo to understand established patterns before making changes
When selecting commands to run (dev, build, test) based on detected tooling
When debugging issues caused by mismatched configurations or non-standard layouts
When onboarding teammates by sharing a concise project context

Quick Start

Step 1: Let project-awareness scan the repository to identify project type, key files, and conventions.
Step 2: Review detected scripts, dirs, and patterns to form the context you’ll work with.
Step 3: Use the gathered context automatically during tasks; ask for specifics if context is missing.

Best Practices

Let the detector infer project type from root files before making changes
Prioritize reading the most relevant files for the current task (configs, tests, then code)
Cross-check detected scripts against actual commands in package.json, Makefile, or build files
Map discovered directory conventions (src/, components/, api/, tests/) to your changes
Honor naming, import, and export patterns to minimize refactors and confusion

Example Use Cases

Node.js app with package.json and scripts like dev/build/test
Rust project with Cargo.toml and src/
Python project with pyproject.toml and requirements.txt
Go service with go.mod and internal/ or cmd/ directories
Flutter app with pubspec.yaml and lib/

Frequently Asked Questions

Add this skill to your agents