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

> Discover the programming languages in Leonxlnx/taste-skill: Bash, Markdown, TypeScript/TSX, JSON, and plain text. Learn about AI design skill definitions with no compiled runtime.

- Repository: [Leon Lin/taste-skill](https://github.com/Leonxlnx/taste-skill)
- Tags: getting-started
- Published: 2026-05-26

---

**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`](https://github.com/Leonxlnx/taste-skill/blob/main/SKILL.md) documentation files. Located at [`skill.sh`](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) in the repository root, this script maintains a local registry using associative arrays to resolve skill identifiers to file paths.

```bash
#!/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`](https://github.com/Leonxlnx/taste-skill/blob/main/SKILL.md) file that combines design-system guidance with embedded code snippets. The primary skill definition lives at [`skills/taste-skill/SKILL.md`](https://github.com/Leonxlnx/taste-skill/blob/main/skills/taste-skill/SKILL.md), with a legacy version maintained at [`skills/taste-skill-v1/SKILL.md`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/skills/taste-skill/SKILL.md) provides a complete React component implementation:

```tsx
"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`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh)**: The sole Bash executable handling skill name-to-path resolution
- **[`skills/taste-skill/SKILL.md`](https://github.com/Leonxlnx/taste-skill/blob/main/skills/taste-skill/SKILL.md)**: Primary markdown skill definition containing TypeScript/TSX examples
- **[`skills/taste-skill-v1/SKILL.md`](https://github.com/Leonxlnx/taste-skill/blob/main/skills/taste-skill-v1/SKILL.md)**: Legacy skill version in markdown format
- **[`opencode.json`](https://github.com/Leonxlnx/taste-skill/blob/main/opencode.json)**: JSON metadata cache for repository tooling
- **[`skills/llms.txt`](https://github.com/Leonxlnx/taste-skill/blob/main/skills/llms.txt)**: Plain-text enumeration of supported LLMs
- **[`README.md`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/skill.sh) script functions as a local registry mapper that resolves skill names to their corresponding [`SKILL.md`](https://github.com/Leonxlnx/taste-skill/blob/main/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`](https://github.com/Leonxlnx/taste-skill/blob/main/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.