What Is the Purpose of the `src` Folder in the Leonxlnx/taste-skill Repository?

The Leonxlnx/taste-skill repository intentionally omits a src folder and houses all executable logic, skill definitions, and runtime assets directly in the repository root and specialized subdirectories like skills/ and assets/.

The taste-skill project follows a documentation-first architecture that deliberately avoids traditional source code hierarchies. Instead of compiling code from a centralized src directory, this repository uses a lightweight skill engine that parses Markdown specifications and shell scripts at runtime. Understanding this layout clarifies why the project functions without the conventional source folder found in typical software repositories.

Why There Is No src Folder in taste-skill

Unlike conventional Python, JavaScript, or Java projects that organize compiled or interpreted code under src/, the taste-skill repository treats skill definitions as the primary source of truth. Each skill is documented in a SKILL.md file containing parameters, capabilities, and usage examples, while the [skill.sh](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) script serves as the runtime entry point.

This design eliminates the need for a separate source directory because:

• No compilation step is required – The engine interprets Markdown and shell commands at runtime.
• Skills are data-driven – Configuration lives in human-readable documents rather than traditional source files.
• Simplicity is prioritized – The flat structure makes skills easy to version, review, and extend without navigating deep directory hierarchies.

Repository Structure and Key Components

The following directories and files comprise the functional equivalent of what would traditionally live in src/:

• [skill.sh](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) – The main executable script that initializes the skill engine and wires together skill definitions.
• skills/ – Contains subdirectories for each individual skill, each housing a SKILL.md specification file and related configuration.
• assets/ – Images and media referenced by the README and skill documentation.
• examples/ – Screenshots and visual demonstrations of skill outputs.
• research/ – Markdown files documenting architectural decisions, root-cause analyses, and design patterns.
• [README.md](https://github.com/Leonxlnx/taste-skill/blob/main/README.md) – Project overview, installation instructions, and usage guidelines.

How the Skill Engine Works Without Source Code

The [skill.sh](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) script functions as the runtime environment, parsing the SKILL.md files located in skills/ subdirectories to register available capabilities. When executed, the script reads these Markdown specifications to determine available commands, parameters, and execution logic, effectively treating documentation as executable configuration.

This approach means the repository contains no compiled artifacts and requires no build step—the code that runs is the same code you read in the skill definitions.

Code Example: Running the Skill Engine

Since there is no src folder to build, you launch the application directly from the repository root:

# Clone the repository

git clone https://github.com/Leonxlnx/taste-skill.git
cd taste-skill

# Make the launcher executable

chmod +x skill.sh

# Execute the skill engine

./skill.sh

The script automatically discovers all skills defined in the skills/ directory by scanning for SKILL.md files and loading their specifications into the runtime.

Summary

• The Leonxlnx/taste-skill repository contains no src folder by design.
• All logic resides in [skill.sh](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) and Markdown skill definitions under skills/.
• The architecture is documentation-driven, using SKILL.md files as both specification and configuration.
• No compilation or build process is required; the shell script parses Markdown at runtime.
• Supporting directories like assets/, examples/, and research/ replace traditional source code organizational patterns.

Frequently Asked Questions

Why doesn't the taste-skill repository have a src folder?

The project follows a skill-centric architecture where functionality is defined in Markdown documents rather than traditional source code. The [skill.sh](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) script parses these SKILL.md files at runtime, eliminating the need for a separate source directory or compilation step. This makes the system more accessible for non-developers and easier to maintain through simple documentation updates.

Where is the main executable code located if not in src?

The primary executable is the [skill.sh](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) script located in the repository root. This launcher reads skill definitions from the skills/ directory, where each skill resides in its own folder containing a SKILL.md file that defines the skill's behavior, parameters, and execution logic.

How do I run taste-skill without a traditional src directory?

Since there is no build step or compilation required, you execute the shell script directly after cloning. Make the [skill.sh](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) file executable with chmod +x skill.sh and run ./skill.sh from the repository root. The script will automatically discover and load all skills defined in the skills/ directory without needing to reference a src folder.

Is taste-skill a compiled or interpreted project?

The project is interpreted at runtime. The [skill.sh](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) script acts as an interpreter for the Markdown-based skill definitions found in skills/*/SKILL.md. This interpreted approach allows for immediate updates to skill behavior by simply editing Markdown files, with no need to recompile source code from a src directory.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}