code-journey

Analyze Ori code execution through the compiler pipeline and LLVM IR.

14|1|Updated Jan 20, 2026
One-click install
npx skills add https://github.com/upstat-io/ori-lang --skill code-journey
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: code-journey
Source: https://github.com/upstat-io/ori-lang/tree/main/.claude/skills/code-journey
Command: npx skills add https://github.com/upstat-io/ori-lang --skill code-journey

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill requires ir_parser, instruction_metrics, arc_metrics, attribute_metrics, control_flow_metrics, binary_metrics, extract-metrics, score, extract_ir_from_results, and includes scripts (resource) and references (resource) components.

What problem does it solve?

This Skill allows you to trace the execution of Ori code through the entire compiler pipeline, from source text to final machine code, identifying inefficiencies and potential issues.

Core Features & Use Cases

  • End-to-End Tracing: Follow code through lexing, parsing, type checking, interpretation, and LLVM codegen.
  • Deep Scrutiny: Analyze generated LLVM IR for instruction purity, ARC correctness, attribute usage, control flow, and binary quality.
  • Use Case: Understand exactly how your Ori code is transformed into machine instructions, pinpointing performance bottlenecks or correctness issues in the compiler itself.

Quick Start

Use the code-journey skill to trace the execution of the provided file 'plans/code-journeys/01-arithmetic.ori'.

Frequently Asked Questions about code-journey

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I trace Ori code execution through the compiler pipeline?

Trace Ori code execution through the compiler pipeline by using the code-journey skill to automate end-to-end analysis. It follows code through lexing, parsing, type checking, interpretation, and LLVM codegen to identify inefficiencies and potential issues.

How does LLVM IR analysis help debug performance bottlenecks in Ori code?

LLVM IR analysis debugs performance bottlenecks by performing deep scrutiny on generated intermediate representation. It identifies instruction inefficiencies, ARC correctness issues, attribute application, control flow patterns, and binary quality metrics to pinpoint exact problems.

Do I need the Ori compiler toolchain to analyze control flow and binary metrics?

Yes, analyzing control flow and binary metrics requires access to the Ori compiler toolchain and associated analysis scripts. The skill automates scrutiny of generated LLVM IR but depends on the external toolchain to generate the necessary intermediate representation.

What is the best way to identify ARC correctness issues in generated LLVM IR?

The best way to identify ARC correctness issues in generated LLVM IR is to automate analysis through the compiler pipeline. This approach scrutinizes instruction purity, attribute usage, and control flow patterns to detect memory management bottlenecks or correctness issues.

Can I analyze lexer and parser output for type checking inefficiencies in Ori?

Yes, you can analyze lexer and parser output for type checking inefficiencies in Ori. The skill traces execution from source text through type checking and interpretation, ultimately examining the final machine code generation for potential compiler issues.

What are the limitations when extracting instruction metrics from LLVM codegen?

Limitations when extracting instruction metrics from LLVM codegen include dependency on the external Ori compiler toolchain. Without the associated analysis scripts and toolchain environment, the skill cannot generate or evaluate the intermediate representation required for binary quality metrics.