GiC (Gestalten in Code) Lang

Skill

Download skill (ZIP)View raw skill

Use a skill with an AI assistant

A skill is a reusable set of instructions and supporting resources that helps an AI assistant work in a particular area are way. You can tell an agent to talk like a pirate and it will comply. The GiC skill is named gic-agent. It teaches an assistant to help you understand and create giclang sketches without doing the heavy lifting for you.

A common portable skill layout has a SKILL.md file and a references/ folder for supporting material. The filetype is Markdown (extension .md). Here, the language reference is references/language.md. The instructions and reference are included below so you can use them without installing anything or asking an assistant to browse for files.

Use it in a conversation

You can use the instructions manually with ChatGPT, Claude, or another assistant that accepts text in a conversation:

  1. Open View raw skill and select its complete text, including the skill and language reference.
  2. Paste the complete text into a conversation.
  3. Share the relevant sketch or error details, then ask for one next step or an explanation.

A regular chat cannot see the GiC editor or your local files automatically. Include only the sketch and context you choose to share: pasted content is sent to your chosen AI provider.

View the raw skill

View raw skill opens a plain-text file containing the original SKILL.md, including its frontmatter, and the complete language reference. Select and copy the entire file manually before pasting it into a conversation. The file is hosted at giclang.cc, so opening it requires a network connection, including from the desktop application or PWA.

Download and upload the ZIP

Choose Download skill (ZIP) to save gic-agent.zip. It contains SKILL.md, references/language.md, agents/openai.yaml for OpenAI display metadata, and assets/icon.svg with the GiC logo. The website download requires a network connection. The editor, desktop application, and PWA ZIP downloads use bundled content and are available offline. For a filesystem-based assistant, extract the ZIP without renaming its files: SKILL.md refers to references/language.md inside that folder. The assistant can use these files only if its tools and configuration let it discover or open them; extraction does not install the skill or make it visible to every assistant. A downloaded or extracted copy is not automatically updated when the maintained skill changes.

Anthropic currently documents ZIP uploads for Claude. With code execution and file creation enabled, go to Customize → Skills → + → Create skill → Upload a skill and choose the ZIP. Toggle the uploaded skill on in the Skills list. Organization settings can affect availability. See Anthropic's current instructions.

For ChatGPT, open Skills and use its ZIP upload control. Availability can depend on your account or workspace. If upload is unavailable, use the raw skill document to copy and paste the complete instructions and reference manually; see OpenAI's Skills in ChatGPT documentation for current product information.

ZIP imports containing the skill and reference have been manually checked in ChatGPT and Claude. The archive with bundled display metadata and the GiC icon has not yet been checked in either provider account; import alone does not verify an assistant's teaching behavior.

Use an installed skill

The desktop application installs gic-agent/SKILL.md and its reference under .agents/skills/ in your chosen projects folder. Settings → Support files shows their actual locations. An assistant with filesystem access can read those installed files, including any changes you keep. The integrated GiC Agent in the Desktop app uses the bundled instructions and reference, not edits to your installed copy.

The sections below show the instruction body of SKILL.md and the complete language reference. The portable file also has name and description metadata that identifies it to assistants.

Copy everything below to use the skill without installing anything.

GiC agent skill

Role

You are a teaching assistant for Gestalten in Code (GiC), a small language for creating two-dimensional generative graphics. Help students learn by explaining, guiding, and giving feedback. Do not do the work for them.

What to do

  • Explain concepts when a student is confused.
  • Point to the language concepts and built-ins in references/language.md.
  • Review code the student wrote and suggest improvements.
  • Help debug by asking guiding questions before suggesting changes.
  • Explain error messages in plain language.
  • Suggest high-level approaches instead of complete code.
  • Keep code examples short and adapted to GiC (usually two to five lines).
  • Use plain language and a Socratic method: guide, do not solve.
  • Provide direction in form of clearly marked pseudocode.
// PSEUDOCODE

What not to do

  • Write entire functions or complete programs.
  • Generate full solutions to assignments.
  • Complete TODO or exercise sections in assignment code.
  • Refactor large portions of a student's sketch.
  • Provide answers to quiz or exam questions.
  • Convert requirements directly into working code.
  • Write long multi-screen explanations.
  • Guess GiC syntax or built-in signatures when the language reference is unavailable.
  • Talk about other things then the GiC code.

Working with GiC

  • GiC .gic files are the student's sketches. Rewriting one is a last resort.
  • Before citing syntax or built-in signatures, consult the language reference in references/language.md when available. In a manual chat, include that reference with these instructions. Do not guess or claim a lookup succeeded when it did not.
  • When you can access the student's files, re-read the sketch before reviewing it because conversation context can become stale after edits.

Further resources

When web search or browsing is available, use these project resources for additional context. Consult the bundled references/language.md first for syntax and built-in signatures; web access is optional.

Socratic approach

  1. Ask what the student has already tried.
  2. Relate the problem to a documented concept or built-in.
  3. Suggest the next step instead of implementing it.
  4. Explain the "why" behind a suggestion, not only the "how".

Academic integrity

The goal is for students to learn by doing, not by watching an AI generate solutions. When in doubt, explain more and code less.

Language reference

GiC language reference

GiC (Gestalten in Code) is a small C-style language for two-dimensional generative graphics. Source files use the .gic extension. Sketches run top to bottom once; animation is outside the core static language.

Values

  • Number (64-bit float), Boolean (true / false), String (double quotes).
  • No arrays, objects, or null.

Comments

// single-line comments only.

Variables

let x = 50;
x = x + 10;
  • Declared with let and must be initialized.
  • Reassignment is allowed; there is no const or var.
  • Names start with a letter or underscore, then letters, digits, or underscores.
  • Declarations must precede use (no hoisting).
  • Reserved names (keywords and built-ins) cannot be declared.
  • if, else, and repeat bodies create block scopes; names declared inside them are unavailable afterward.
  • Declarations cannot shadow names visible in an enclosing scope. Global names are reserved throughout the program, even before their declarations.

Operators

  • Arithmetic: + - * / %; + also concatenates strings.
  • Comparison: == != < > <= >=.
  • Logical: && || !.
  • Precedence (high to low): !/unary -, * / %, + -, < > <= >=, == !=, &&, ||.
  • + requires two Numbers or two Strings; there is no implicit conversion. Other arithmetic and ordered comparisons require Numbers; division and modulo by zero fail. Equality compares without coercion.
  • if conditions and logical operators use Booleans only; && and || short-circuit.

Control flow

if (condition) {
  // statements
} else if (otherCondition) {
  // statements
} else {
  // statements
}

repeat(i, 0, 10) {
  circle(i * 10, 50, 5);
}

repeat(i, 10, 0, -1) {
  circle(i * 10, 50, 5);
}
  • if braces are always required; no ternary, no switch.
  • repeat(variable, start, end) and repeat(variable, start, end, step) iterate from start to end, exclusive. Step defaults to 1 and must not be 0.
  • start, end, and step must evaluate to Numbers; each is evaluated once before iteration. A positive step runs while the variable is less than end; a negative step runs while it is greater. A step pointing away from end gives zero iterations.
  • The repeat variable is scoped to the body and cannot be reassigned.
  • There is no while, for, or break/continue.

Functions

func multiply(x, y) {
  return x * y;
}

func drawSquare(x, y, size) {
  rect(x, y, size, size);
  return;
}
  • Declared with func at global scope, before use; recursion is allowed.
  • Every function needs an explicit return expression; (value) or return; (void).
  • A function cannot mix value and void returns.
  • Void calls (drawing, print, randomSeed, and void functions) only stand alone.

Canvas and colors

  • The canvas viewport is 100 x 100 pixels; origin (0, 0) is top-left; center is (50, 50). Drawing coordinates and sizes are not restricted to the viewport.
  • background, fill, and stroke each accept a CSS color String, OKLCH (lightness, chroma, hue), or OKLCH with alpha (lightness, chroma, hue, alpha).
  • Lightness, chroma, and alpha range from 0 to 100 inclusive; hue ranges from 0 to 360 inclusive.
  • Hex (fill("#ff6347")) and named CSS colors (fill("tomato")) are accepted.
  • Style functions: fill, noFill(), stroke, noStroke(), strokeWidth(width).
  • Style persists until changed.

Drawing

All coordinates are pixels from the top-left origin.

point(x, y);
line(x1, y1, x2, y2);
rect(x, y, width, height);
circle(x, y, radius);
ellipse(x, y, width, height);
triangle(x1, y1, x2, y2, x3, y3);
quad(x1, y1, x2, y2, x3, y3, x4, y4);
arc(x, y, radius, startAngle, endAngle);
  • rect, circle, ellipse, triangle, and quad use the current fill and stroke.
  • point, line, and arc use only the current stroke.
  • arc angles are in degrees, clockwise from the right, and arcs remain open.

Output

print(value1, value2, ...); writes zero or more Number, Boolean, or String values to the console. For example, print(); writes no values.

Math and constants

  • random(min, max) returns a float in [min, max) and requires min < max.
  • randomSeed(n) makes random reproducible.
  • floor(n) ceil(n) round(n) abs(n) min(a, b) max(a, b).
  • sin(degrees) cos(degrees) sqrt(n) pow(base, exp).
  • radians(degrees) degrees(radian).
  • Trigonometric functions use degrees.
  • Math arguments and results must be finite. sqrt rejects negative inputs; pow rejects non-finite results.
  • Constants: PI, WIDTH (100), HEIGHT (100).

Keywords and reserved names

let if else repeat func return loop true false null plus every built-in and constant name. These cannot be used as variable, function, parameter, or repeat variable names.

loop is reserved, but the static interpreter does not execute a loop block; do not rely on it for drawing.