Loki Checkout Agent Skills for Magento 2

Agent skills for working with Loki Checkout in Magento 2 projects.

This repository contains focused instructions, conventions, and workflows that help AI coding agents understand and modify Loki Checkout implementations safely and consistently.

Purpose

Loki Checkout introduces its own architecture, frontend patterns, and extension mechanisms on top of Magento 2. The skills in this repository provide Loki Checkout-specific context.

They are intended to help agents:

• Understand the Loki Checkout architecture.
• Identify the correct extension point before modifying checkout behaviour.
• Follow established Loki Checkout frontend patterns.
• Avoid assumptions based on Magento's default checkout.
• Make smaller and more maintainable changes.
• Review existing Loki Checkout implementations.
• Debug checkout behaviour systematically.

What is an agent skill?

An agent skill is a set of focused instructions that gives an AI coding agent domain-specific knowledge and working conventions.

Skills do not replace the Loki Checkout documentation or Magento 2 documentation. They provide practical context for an agent performing development tasks inside a codebase.

A skill can describe:

• Architectural concepts.
• Project conventions.
• Recommended implementation patterns.
• Common pitfalls.
• Debugging workflows.
• Review criteria.
• Decisions that require additional investigation.

The goal is not to give an agent a large knowledge dump. A useful skill should help the agent make better decisions while working on a concrete task.

Repository structure

The exact structure may evolve as the skill set grows.

.
├── skills/
│   ├── ...
│   │   └── SKILL.md
│   └── ...
│       └── SKILL.md
└── README.md

Each skill should focus on a specific Loki Checkout concern.

Where possible, keep skills independent. An agent should be able to load only the context relevant to its current task.

Using these skills

Clone the repository or make the skills available to your preferred coding agent.

git clone <repository-url>

The exact installation or discovery mechanism depends on the agent you use.

When working on a Loki Checkout task, make the relevant skill available to the agent before implementation.

For example, a task might be described as:

Add a checkout component to a Loki Checkout implementation. Read the relevant Loki Checkout skills before analysing the existing implementation or writing code.

Agents should still inspect the actual Magento 2 project.

A skill describes Loki Checkout patterns and conventions. The project remains the source of truth for:

• Installed Loki Checkout versions.
• Available PHP and JavaScript APIs.
• Module configuration.
• Existing customisations.
• Theme conventions.
• Third-party integrations.

Do not assume an API exists solely because a similar API exists in another Magento checkout implementation.

Principles

Inspect before implementing

Agents should inspect the existing implementation before proposing a change.

Relevant files, modules, configuration, and existing extension patterns should be identified first.

Use Loki Checkout patterns

Do not automatically reuse patterns from Magento's default Knockout checkout, Luma, or other checkout implementations.

If a Loki Checkout extension mechanism exists, prefer it.

Verify APIs

Loki Checkout and project-specific APIs should be verified against the installed source code or current documentation.

Do not invent class names, events, configuration keys, JavaScript APIs, or XML structures.

Prefer focused changes

Checkout changes can affect customer conversion and order placement.

Prefer small changes with a clear responsibility over broad rewrites.

Preserve Magento conventions

Loki Checkout-specific patterns exist within a Magento 2 application.

Magento conventions still matter for areas such as:

• Dependency injection.
• Module boundaries.
• Plugins and observers.
• Configuration.
• Layout XML.
• Escaping.
• Translation.
• Content Security Policy.
• Cache behaviour.

State uncertainty

When the installed version or available API cannot be verified, the agent should state the uncertainty and inspect the project before continuing.

Guessing an implementation detail is not an acceptable substitute for verification.

Contributing

Contributions are welcome.

A useful skill should be:

• Focused on a concrete development concern.
• Specific to Loki Checkout where relevant.
• Based on verifiable behaviour.
• Clear about version-specific assumptions.
• Practical for an agent performing implementation work.
• Concise enough to load as working context.

Avoid generic Magento 2 advice unless it directly affects how a Loki Checkout task should be approached.

When adding a skill:

1. Create a dedicated skill directory.
2. Add a SKILL.md.
3. Clearly describe when the skill applies.
4. Document the recommended workflow or implementation pattern.
5. Include important constraints and common mistakes.
6. Review instructions from the perspective of an agent working in an unfamiliar Magento 2 project.

Pull requests that improve accuracy, clarify existing instructions, or add missing Loki Checkout workflows are appreciated.

Disclaimer

These skills are intended to assist AI coding agents.

Generated code and implementation decisions should still be reviewed and tested by an experienced Magento 2 developer before deployment to production.

Loki Checkout, Magento, and related product names may be trademarks of their respective owners.