agentleFS
MindrallyMindrally/skills/lua/SKILL.md

lua

Skill275 starsChanged 39 days agoApache-2.0View on GitHub

Lua development guidelines covering tables, metatables, error handling, game development, and performance optimization.

3 other projects use a version of this.

Adopted by

Most recently taken up by

The file

Show its rules and text

We split this skill into the rules it gives an agent

13 rules. About 0 are common, 13 are distinctive, and 0 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈13

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Write clear, concise Lua code that follows idiomatic patterns

    line 15
  2. Distinctive:

    Use metatables and metamethods appropriately

    line 25
  3. Distinctive:

    Follow Lua's 1-based indexing consistently

    line 26
  4. Distinctive:

    Use local functions for module-private code

    line 38
  5. Distinctive:

    Keep files focused and manageable

    line 40
  6. Distinctive:

    Use pcall/xpcall for protected calls

    line 45
  7. Distinctive:

    Use assert() for preconditions

    line 47
  8. Distinctive:

    Prefer local variables over global

    line 53
  9. Distinctive:

    Use weak tables for caching when appropriate

    line 58
  10. Distinctive:

    Use metatables for object-oriented patterns

    line 69
  11. Distinctive:

    Use __newindex for property validation

    line 71
  12. Distinctive:

    Write unit tests for critical functions

    line 84
  13. Distinctive:

    Document function parameters and return values

    line 85

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Lua Development

You are an expert in Lua programming with deep knowledge of tables, metatables, and game development patterns.

Core Principles

  • Write clear, concise Lua code that follows idiomatic patterns
  • Leverage Lua's dynamic typing while maintaining code clarity
  • Prioritize modularity and code reusability
  • Focus on end-user experience across all code contributions

Lua-Specific Practices

  • Maximize local variables for performance improvements
  • Leverage tables effectively for data structures
  • Implement error handling via pcall/xpcall functions
  • Use metatables and metamethods appropriately
  • Follow Lua's 1-based indexing consistently

Naming Conventions

  • snake_case for variables and functions
  • PascalCase for classes/modules
  • UPPERCASE for constants
  • Underscore prefix for private functions/variables

Code Organization

  • Group related functions into modules
  • Use local functions for module-private code
  • Organize into logical sections with comments
  • Keep files focused and manageable
  • Utilize require() for dependencies

Error Handling

  • Use pcall/xpcall for protected calls
  • Handle nil values explicitly
  • Use assert() for preconditions
  • Provide informative error messages
  • Implement proper error propagation

Performance Optimization

  • Prefer local variables over global
  • Cache frequently accessed values
  • Minimize table creation in loops
  • Pre-allocate tables when size is known
  • Reuse tables when possible
  • Use weak tables for caching when appropriate

Memory Management

  • Be mindful of table creation in loops
  • Reuse tables when possible
  • Use weak tables for caching when appropriate
  • Monitor memory usage in long-running applications

Metatables and OOP

  • Use metatables for object-oriented patterns
  • Implement __index for inheritance
  • Use __newindex for property validation
  • Leverage metamethods appropriately

Game Development

  • Implement proper game loop structure
  • Optimize collision detection efficiency
  • Manage game state effectively
  • Handle input processing efficiently
  • Integrate properly with game engines (Love2D, Corona, etc.)

Testing and Documentation

  • Write unit tests for critical functions
  • Document function parameters and return values
  • Include usage examples for public interfaces

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.