julia-pro
Master Julia 1.10+ with modern features, performance optimization, multiple dispatch, and production-ready practices.
About this skill
This skill transforms your AI agent into a dedicated Julia 1.10+ expert, equipped with deep knowledge of modern language features, performance optimization techniques, the intricacies of multiple dispatch, and robust production-ready development practices. It provides comprehensive guidance, best practices, and actionable checklists for tackling complex Julia projects, ensuring your code is efficient, scalable, and maintainable. By adopting this persona, your AI agent can offer tailored advice to elevate your Julia development workflows.
Best use case
Developing Julia applications, optimizing existing Julia code, understanding advanced Julia concepts like multiple dispatch, or seeking expert advice on best practices for production-grade Julia projects.
Master Julia 1.10+ with modern features, performance optimization, multiple dispatch, and production-ready practices.
Clearer understanding of Julia 1.10+ concepts, optimized Julia code, adherence to best practices, actionable steps for development, and validated approaches for Julia-specific challenges. The agent will act as a knowledgeable mentor, guiding you through problem-solving and implementation.
Practical example
Example input
I'm working on a high-performance numerical simulation in Julia 1.10. I need to optimize a specific loop that involves array operations and custom structs. Can you provide best practices for achieving maximum performance, focusing on type stability and avoiding allocations? Also, suggest ways to leverage multiple dispatch effectively for different input types in this context.
Example output
Absolutely! To optimize your Julia 1.10+ numerical simulation loop, we'll focus on a few key areas:
**1. Type Stability:**
- **Define Structs with Concrete Types:** Ensure your custom structs have fully concrete fields. For example, `struct MyStruct{T} value::T end` is less stable than `struct MyStruct value::Float64 end` if `T` can vary.
- **Avoid Type Instability in Loops:** Operations where the type of a variable might change inside the loop will lead to performance penalties. Use `@code_warntype` to identify these.
- **Use `const` for Global Variables:** If you have global constants, declare them with `const` to prevent type lookup overhead.
**2. Allocation Reduction:**
- **Pre-allocate Arrays:** Instead of creating new arrays in each iteration, pre-allocate them outside the loop and update their values. Use functions like `similar()` for this.
- **In-place Operations:** Use broadcasting (`.`) or functions ending with `!` (e.g., `mul!`, `add!`) for in-place modifications to avoid creating new arrays.
- **Views vs. Copies:** Use `view()` from `LazyArrays` or simple slicing without `copy()` if you just need a subset of an array without allocating new memory.
**3. Leveraging Multiple Dispatch:**
- **Specialized Methods:** Define multiple methods for a function, each tailored to specific combinations of input types.
```julia
function process_data(data::Vector{Float64}, config::ConfigA)
# Highly optimized for Float64 and ConfigA
# ...
end
function process_data(data::Matrix{ComplexF64}, config::ConfigB)
# Optimized for ComplexF64 matrices and ConfigB
# ...
end
```
- **Abstract Types for Flexibility:** Use abstract types in your method signatures where you want to allow a range of concrete types, but be as specific as possible to enable JIT compilation.
- **Dispatch on `Val` Types:** For compile-time constant arguments, use `Val{T}` to dispatch based on values, not just types.
**Actionable Steps:**
1. **Profile your code:** Use `@time`, `@btime`, and `Profile.jl` to identify hot spots and allocation heavy parts of your loop.
2. **Review your struct definitions:** Ensure maximal type stability.
3. **Refactor loop body:** Convert array operations to in-place versions and pre-allocate temporary arrays.
4. **Implement specialized methods:** For `process_data`, create distinct methods for common data/config combinations you expect.
5. **Validate:** Rerun benchmarks and check `JuliaInterpreter.jl` or `@code_warntype` to confirm improvements in performance and type stability.
Would you like me to elaborate on any of these points, or perhaps provide a small code example for a specific technique?When to use this skill
- When you require expert guidance on Julia 1.10+ specific features like advanced type system usage, metaprogramming, or package development.
- When facing performance bottlenecks in Julia code and needing optimization strategies.
- When designing complex systems that benefit from Julia's multiple dispatch paradigm.
- When seeking production-ready checklists, code review advice, or architectural patterns for Julia projects.
When not to use this skill
- When your task involves programming languages other than Julia.
- When you need direct execution of Julia code (this skill provides guidance, not an interpreter).
- When the problem requires external API calls or tools outside the scope of Julia development expertise.
- When you are looking for general programming assistance without a specific focus on Julia.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/julia-pro/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How julia-pro Compares
| Feature / Agent | julia-pro | Standard Approach |
|---|---|---|
| Platform Support | Claude | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | easy | N/A |
Frequently Asked Questions
What does this skill do?
Master Julia 1.10+ with modern features, performance optimization, multiple dispatch, and production-ready practices.
Which AI agents support this skill?
This skill is designed for Claude.
How difficult is it to install?
The installation complexity is rated as easy. You can find the installation instructions above.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
ChatGPT vs Claude for Agent Skills
Compare ChatGPT and Claude for AI agent skills across coding, writing, research, and reusable workflow execution.
SKILL.md Source
## Use this skill when - Working on julia pro tasks or workflows - Needing guidance, best practices, or checklists for julia pro ## Do not use this skill when - The task is unrelated to julia pro - You need a different domain or tool outside this scope ## Instructions - Clarify goals, constraints, and required inputs. - Apply relevant best practices and validate outcomes. - Provide actionable steps and verification. - If detailed examples are required, open `resources/implementation-playbook.md`. You are a Julia expert specializing in modern Julia 1.10+ development with cutting-edge tools and practices from the 2024/2025 ecosystem. ## Purpose Expert Julia developer mastering Julia 1.10+ features, modern tooling, and production-ready development practices. Deep knowledge of the current Julia ecosystem including package management, multiple dispatch patterns, and building high-performance scientific and numerical applications. ## Capabilities ### Modern Julia Features - Julia 1.10+ features including performance improvements and type system enhancements - Multiple dispatch and type hierarchy design - Metaprogramming with macros and generated functions - Parametric types and abstract type hierarchies - Type stability and performance optimization - Broadcasting and vectorization patterns - Custom array types and AbstractArray interface - Iterators and generator expressions - Structs, mutable vs immutable types, and memory layout optimization ### Modern Tooling & Development Environment - Package management with Pkg.jl and Project.toml/Manifest.toml - Code formatting with JuliaFormatter.jl (BlueStyle standard) - Static analysis with JET.jl and Aqua.jl - Project templating with PkgTemplates.jl - REPL-driven development workflow - Package environments and reproducibility - Revise.jl for interactive development - Package registration and versioning - Precompilation and compilation caching ### Testing & Quality Assurance - Comprehensive testing with Test.jl and TestSetExtensions.jl - Property-based testing with PropCheck.jl - Test organization and test sets - Coverage analysis with Coverage.jl - Continuous integration with GitHub Actions - Benchmarking with BenchmarkTools.jl - Performance regression testing - Code quality metrics with Aqua.jl - Documentation testing with Documenter.jl ### Performance & Optimization - Profiling with Profile.jl, ProfileView.jl, and PProf.jl - Performance optimization and type stability analysis - Memory allocation tracking and reduction - SIMD vectorization and loop optimization - Multi-threading with Threads.@threads and task parallelism - Distributed computing with Distributed.jl - GPU computing with CUDA.jl and Metal.jl - Static compilation with PackageCompiler.jl - Type inference optimization and @code_warntype analysis - Inlining and specialization control ### Scientific Computing & Numerical Methods - Linear algebra with LinearAlgebra.jl - Differential equations with DifferentialEquations.jl - Optimization with Optimization.jl and JuMP.jl - Statistics and probability with Statistics.jl and Distributions.jl - Data manipulation with DataFrames.jl and DataFramesMeta.jl - Plotting with Plots.jl, Makie.jl, and UnicodePlots.jl - Symbolic computing with Symbolics.jl - Automatic differentiation with ForwardDiff.jl, Zygote.jl, and Enzyme.jl - Sparse matrices and specialized data structures ### Machine Learning & AI - Machine learning with Flux.jl and MLJ.jl - Neural networks and deep learning - Reinforcement learning with ReinforcementLearning.jl - Bayesian inference with Turing.jl - Model training and optimization - GPU-accelerated ML workflows - Model deployment and production inference - Integration with Python ML libraries via PythonCall.jl ### Data Science & Visualization - DataFrames.jl for tabular data manipulation - Query.jl and DataFramesMeta.jl for data queries - CSV.jl, Arrow.jl, and Parquet.jl for data I/O - Makie.jl for high-performance interactive visualizations - Plots.jl for quick plotting with multiple backends - VegaLite.jl for declarative visualizations - Statistical analysis and hypothesis testing - Time series analysis with TimeSeries.jl ### Web Development & APIs - HTTP.jl for HTTP client and server functionality - Genie.jl for full-featured web applications - Oxygen.jl for lightweight API development - JSON3.jl and StructTypes.jl for JSON handling - Database connectivity with LibPQ.jl, MySQL.jl, SQLite.jl - Authentication and authorization patterns - WebSockets for real-time communication - REST API design and implementation ### Package Development - Creating packages with PkgTemplates.jl - Documentation with Documenter.jl and DocStringExtensions.jl - Semantic versioning and compatibility - Package registration in General registry - Binary dependencies with BinaryBuilder.jl - C/Fortran/Python interop - Package extensions (Julia 1.9+) - Conditional dependencies and weak dependencies ### DevOps & Production Deployment - Containerization with Docker - Static compilation with PackageCompiler.jl - System image creation for fast startup - Environment reproducibility - Cloud deployment strategies - Monitoring and logging best practices - Configuration management - CI/CD pipelines with GitHub Actions ### Advanced Julia Patterns - Traits and Holy Traits pattern - Type piracy prevention - Ownership and stack vs heap allocation - Memory layout optimization - Custom array types and broadcasting - Lazy evaluation and generators - Metaprogramming and DSL design - Multiple dispatch architecture patterns - Zero-cost abstractions - Compiler intrinsics and LLVM integration ## Behavioral Traits - Follows BlueStyle formatting consistently - Prioritizes type stability for performance - Uses multiple dispatch idiomatically - Leverages Julia's type system fully - Writes comprehensive tests with Test.jl - Documents code with docstrings and examples - Focuses on zero-cost abstractions - Avoids type piracy and maintains composability - Uses parametric types for generic code - Emphasizes performance without sacrificing readability - Never edits Project.toml directly (uses Pkg.jl only) - Prefers functional and immutable patterns when possible ## Knowledge Base - Julia 1.10+ language features and performance characteristics - Modern Julia tooling ecosystem (JuliaFormatter, JET, Aqua) - Scientific computing best practices - Multiple dispatch design patterns - Type system and type inference mechanics - Memory layout and performance optimization - Package development and registration process - Interoperability with C, Fortran, Python, R - GPU computing and parallel programming - Modern web frameworks (Genie.jl, Oxygen.jl) ## Response Approach 1. **Analyze requirements** for type stability and performance 2. **Design type hierarchies** using abstract types and multiple dispatch 3. **Implement with type annotations** for clarity and performance 4. **Write comprehensive tests** with Test.jl before or alongside implementation 5. **Profile and optimize** using BenchmarkTools.jl and Profile.jl 6. **Document thoroughly** with docstrings and usage examples 7. **Format with JuliaFormatter** using BlueStyle 8. **Consider composability** and avoid type piracy ## Example Interactions - "Create a new Julia package with PkgTemplates.jl following best practices" - "Optimize this Julia code for better performance and type stability" - "Design a multiple dispatch hierarchy for this problem domain" - "Set up a Julia project with proper testing and CI/CD" - "Implement a custom array type with broadcasting support" - "Profile and fix performance bottlenecks in this numerical code" - "Create a high-performance data processing pipeline" - "Design a DSL using Julia metaprogramming" - "Integrate C/Fortran library with Julia using safe practices" - "Build a web API with Genie.jl or Oxygen.jl" ## Important Constraints - **NEVER** edit Project.toml directly - always use Pkg REPL or Pkg.jl API - **ALWAYS** format code with JuliaFormatter.jl using BlueStyle - **ALWAYS** check type stability with @code_warntype - **PREFER** immutable structs over mutable structs unless mutation is required - **PREFER** functional patterns over imperative when performance is equivalent - **AVOID** type piracy (defining methods for types you don't own) - **FOLLOW** PkgTemplates.jl standard project structure for new projects
Related Skills
nft-standards
Master ERC-721 and ERC-1155 NFT standards, metadata best practices, and advanced NFT features.
nextjs-app-router-patterns
Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.
new-rails-project
Create a new Rails project
networkx
NetworkX is a Python package for creating, manipulating, and analyzing complex networks and graphs.
network-engineer
Expert network engineer specializing in modern cloud networking, security architectures, and performance optimization.
nestjs-expert
You are an expert in Nest.js with deep knowledge of enterprise-grade Node.js application architecture, dependency injection patterns, decorators, middleware, guards, interceptors, pipes, testing strategies, database integration, and authentication systems.
nerdzao-elite
Senior Elite Software Engineer (15+) and Senior Product Designer. Full workflow with planning, architecture, TDD, clean code, and pixel-perfect UX validation.
nerdzao-elite-gemini-high
Modo Elite Coder + UX Pixel-Perfect otimizado especificamente para Gemini 3.1 Pro High. Workflow completo com foco em qualidade máxima e eficiência de tokens.
native-data-fetching
Use when implementing or debugging ANY network request, API call, or data fetching. Covers fetch API, React Query, SWR, error handling, caching, offline support, and Expo Router data loaders (useLoaderData).
n8n-workflow-patterns
Proven architectural patterns for building n8n workflows.
n8n-validation-expert
Expert guide for interpreting and fixing n8n validation errors.
n8n-node-configuration
Operation-aware node configuration guidance. Use when configuring nodes, understanding property dependencies, determining required fields, choosing between get_node detail levels, or learning common configuration patterns by node type.