What Programming Languages Are Used in Leonxlnx/taste-skill?

The Leonxlnx/taste-skill repository primarily uses Bash, Markdown, TypeScript/TSX, JSON, and plain text to define AI-driven design skills, containing no compiled application runtime.

The Leonxlnx/taste-skill repository functions as a specialized knowledge-base for AI-assisted design workflows rather than a traditional software application. Its language composition reflects this documentation-first architecture, emphasizing human-readable skill definitions over executable binaries. Every file in the source tree serves the specific purpose of mapping skill names to implementation guidance or providing executable helpers for skill discovery.

Core Programming Languages in the Repository

The repository contains five distinct language categories, each serving a specific architectural role in the skill-definition ecosystem.

Bash for Skill Registry Operations

The only executable script in the repository is a Bash helper that maps skill names to their corresponding SKILL.md documentation files. Located at skill.sh in the repository root, this script maintains a local registry using associative arrays to resolve skill identifiers to file paths.

#!/usr/bin/env bash

# Local skill registry

declare -A SKILLS=(
  [taste-skill]="skills/taste-skill/SKILL.md"
  [taste-skill-v1]="skills/taste-skill-v1/SKILL.md"
  # …other entries omitted for brevity…

)

if [[ $# -eq 0 ]]; then

  echo "Usage: source ./skill.sh <skill-name>"
  echo "Available skills: ${!SKILLS[@]}"
else
  echo "${SKILLS[$1]}"
fi

This script demonstrates minimal but functional shell scripting patterns, using declare -A for associative arrays and standard conditional logic for argument parsing.

Markdown for Skill Documentation

Markdown constitutes the bulk of the repository's content. Every skill definition resides in a SKILL.md file that combines design-system guidance with embedded code snippets. The primary skill definition lives at skills/taste-skill/SKILL.md, with a legacy version maintained at skills/taste-skill-v1/SKILL.md.

These markdown files serve dual purposes: they provide human-readable documentation for AI-driven design patterns while functioning as the canonical source of truth for skill implementations. The repository treats markdown not merely as documentation but as the primary interface for skill consumption.

TypeScript and TSX for Implementation Examples

While not standalone application files, TypeScript and TSX (TypeScript React) appear extensively as code examples within the markdown documentation. These snippets illustrate real-world implementations of design patterns in React/Next.js environments, often demonstrating Tailwind CSS, Framer Motion, or GSAP integrations.

The "Sticky-Stack – Canonical Skeleton" pattern in skills/taste-skill/SKILL.md provides a complete React component implementation:

"use client";
import { useRef, useEffect } from "react";
import { gsap } from "gsap";
import { ScrollTrigger } from "gsap/ScrollTrigger";

gsap.registerPlugin(ScrollTrigger);

export function StickyStack({ cards }: { cards: React.ReactNode[] }) {
  const ref = useRef<HTMLDivElement>(null);

  useEffect(() => {
    if (!ref.current) return;
    const ctx = gsap.context(() => {
      const cardEls = gsap.utils.toArray<HTMLElement>(".stack-card");
      cardEls.forEach((card, i) => {
        if (i === cardEls.length - 1) return;
        ScrollTrigger.create({
          trigger: card,
          start: "top top",
          endTrigger: cardEls[cardEls.length - 1],
          end: "top top",
          pin: true,
          pinSpacing: false,
        });
        gsap.to(card, {
          scale: 0.92,
          opacity: 0.55,
          ease: "none",
          scrollTrigger: {
            trigger: cardEls[i + 1],
            start: "top bottom",
            end: "top top",
            scrub: true,
          },
        });
      });
    }, ref);
    return () => ctx.revert();
  }, []);

  return (
    <div ref={ref} className="relative">
      {cards.map((card, i) => (
        <div
          key={i}
          className="stack-card sticky top-0 min-h-[100dvh] flex items-center justify-center"
        >
          {card}
        </div>
      ))}
    </div>
  );
}

This example demonstrates modern React patterns including the useRef and useEffect hooks, GSAP's ScrollTrigger plugin integration, and TypeScript type annotations for props and DOM elements.

Supporting Data Formats

Beyond core programming languages, the repository utilizes structured data formats for metadata management and configuration.

JSON for Tooling Metadata

The opencode.json file at the repository root provides JSON-formatted metadata used by internal tooling and caching mechanisms. While no runtime code depends on this file for execution, it represents the machine-readable configuration layer of the knowledge-base.

Plain Text for LLM Configuration

The skills/llms.txt file contains a simple plain-text list of supported language models. Unlike the markdown skill definitions, this file serves as supplemental metadata without executable or structured markup requirements.

Key Files by Language

Understanding what programming languages are used in Leonxlnx/taste-skill requires examining the specific files that define the repository's functionality:

• skill.sh: The sole Bash executable handling skill name-to-path resolution
• skills/taste-skill/SKILL.md: Primary markdown skill definition containing TypeScript/TSX examples
• skills/taste-skill-v1/SKILL.md: Legacy skill version in markdown format
• opencode.json: JSON metadata cache for repository tooling
• skills/llms.txt: Plain-text enumeration of supported LLMs
• README.md: Project overview and entry point documentation

Summary

The Leonxlnx/taste-skill repository demonstrates a documentation-centric architecture using minimal but precise language choices:

• Bash provides the only executable glue code for skill discovery via skill.sh
• Markdown serves as the primary skill definition language and human interface
• TypeScript/TSX supplies production-ready implementation examples embedded within documentation
• JSON handles machine-readable metadata and tooling configuration
• Plain text manages simple enumeration files without markup overhead

No compiled languages such as Python, Java, C++, or Go appear in the source tree. The repository's language selection prioritizes readability, version control efficiency, and direct consumption by both human developers and AI systems.

Frequently Asked Questions

Does Leonxlnx/taste-skill contain any Python or Java code?

No. The repository contains no Python, Java, C++, Ruby, or other compiled programming languages. According to the source code analysis, only Bash scripts, Markdown documentation, TypeScript examples, JSON metadata, and plain text files appear in the repository tree.

What is the purpose of the skill.sh Bash script?

The skill.sh script functions as a local registry mapper that resolves skill names to their corresponding SKILL.md file paths. It uses Bash associative arrays to maintain the mapping and provides a simple command-line interface for skill lookup, making it the only executable file in the Leonxlnx/taste-skill repository.

Are the TypeScript/TSX examples executable or just documentation?

The TypeScript and TSX code function as implementation examples embedded within the Markdown skill definitions. While they represent production-ready React components (such as the GSAP StickyStack implementation in skills/taste-skill/SKILL.md), they serve as reference implementations and documentation rather than standalone executable application files.

Why does a skill repository use Markdown as a primary language?

The repository architecture treats Markdown as the canonical skill definition format because it balances human readability with machine parseability. This approach allows AI systems and developers to consume skill definitions directly from version-controlled documentation files without requiring complex parsers or runtime environments, aligning with the repository's knowledge-base purpose rather than application hosting.

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