Artifacts

Prompts, Instructions, and Toolsets. The unholy trinity of AI-assisted development.

The Artifact Hierarchy

Loaded Vibes uses a layered artifact system that separates concerns and enables customization at multiple levels:

┌─────────────────────────────────────────────────────────────┐
│                      ARTIFACT LAYERS                         │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│   ┌─────────────────┐                                        │
│   │   TOOLSETS      │  ← Capability definitions              │
│   │   .toolset.jsonc│    (what tools are available)          │
│   └────────┬────────┘                                        │
│            │                                                 │
│   ┌────────▼────────┐                                        │
│   │  INSTRUCTIONS   │  ← Behavioral rules                    │
│   │  .instructions.md   (how to use the tools)               │
│   └────────┬────────┘                                        │
│            │                                                 │
│   ┌────────▼────────┐                                        │
│   │    PROMPTS      │  ← Task invocations                    │
│   │   .prompt.md    │    (what to accomplish)                │
│   └─────────────────┘                                        │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Prompts

Prompts are task-specific invocations that combine context with instructions to accomplish specific goals. They're the "what" of AI-assisted development.

Structure

.github/prompts/feature.prompt.mdmarkdown

---
mode: agent
tools:
  - filesystem
  - git
  - github
description: Implement a new feature based on requirements
---

# Feature Implementation

You are implementing a new feature for the project.

## Context
- **Requirements**: #file:docs/PRD.md
- **Tech Specs**: #file:docs/TECH_REQUIREMENTS.md
- **Current Selection**: #selection

## Instructions
Follow the instructions in #file:.github/instructions/features.instructions.md

## Task
Implement the feature described in the current selection:

```
#selection
```

## Deliverables
1. Implementation code in appropriate location
2. Unit tests with >80% coverage
3. Updated documentation
4. Conventional commit message

Invocation

# In VS Code Copilot Chat
#prompt:feature

# Or via CLI
lv prompt run feature --selection "Add user authentication"

✨

Prompt variables

Use #file:, #selection, #codebase, and #terminalLastCommand to inject dynamic context into prompts.

Instructions

Instructions define behavioral rules that shape how AI agents interact with your codebase. They're loaded hierarchically: global → stack → domain.

Structure

.github/instructions/nextjs.instructions.mdmarkdown

---
applyTo: "app/**/*.tsx,components/**/*.tsx"
---

# Next.js Development Instructions

## Component Guidelines
- Use Server Components by default
- Add 'use client' only when necessary
- Prefer composition over prop drilling

## File Conventions
- Use kebab-case for file names
- Colocate tests with components
- Export types from dedicated .types.ts files

## Styling
- Use Tailwind CSS for styling
- Follow the design tokens in globals.css
- Use CSS variables for theming

## Data Fetching
- Use Server Actions for mutations
- Cache aggressively with revalidation tags
- Handle loading and error states

Layering Example

Layer	File	Scope
Global	copilot-instructions.md	All files (**)
Stack	nextjs.instructions.md	app/*/.tsx
Domain	auth.instructions.md	/auth/

Toolsets

Toolsets define what MCP tools are available and how they should be configured for specific tasks. They're the capability layer that enables AI actions.

Structure

.github/toolsets/default.toolset.jsoncjson

{
  "$schema": "https://json.schemastore.org/toolset.json",
  "name": "default",
  "description": "Default toolset for general development",
  "tools": {
    "filesystem": {
      "enabled": true,
      "config": {
        "allowedPaths": ["src/**", "tests/**", "docs/**"],
        "blockedPaths": ["node_modules/**", ".env*"]
      }
    },
    "git": {
      "enabled": true,
      "config": {
        "allowCommit": true,
        "requireConventionalCommits": true,
        "protectedBranches": ["main", "production"]
      }
    },
    "github": {
      "enabled": true,
      "config": {
        "allowPR": true,
        "allowIssues": true,
        "requireReviewers": true
      }
    },
    "postgres": {
      "enabled": true,
      "config": {
        "allowMigrations": false,
        "readOnly": false
      }
    }
  },
  "securityPolicy": {
    "requireApproval": ["destructive"],
    "blockPatterns": ["DROP TABLE", "DELETE FROM", "TRUNCATE"]
  }
}

Tool Categories

Filesystem

Read, write, and navigate project files. Constrained by allowedPaths.

Git

Version control operations. Commits, branches, diffs, and history.

GitHub

Pull requests, issues, reviews, and repository management.

Database

PostgreSQL queries via Prisma MCP. Schema-aware and safe by default.

Memory

Persistent context storage. Knowledge graphs and session state.

Fetch

HTTP requests to external services. Documentation, APIs, packages.

Artifact Locations

.github/
├── prompts/              # Task invocations
│   ├── feature.prompt.md
│   ├── bugfix.prompt.md
│   ├── refactor.prompt.md
│   └── review.prompt.md
├── instructions/         # Behavioral rules
│   ├── nextjs.instructions.md
│   ├── prisma.instructions.md
│   ├── testing.instructions.md
│   └── security.instructions.md
├── toolsets/             # Capability definitions
│   ├── default.toolset.jsonc
│   ├── readonly.toolset.jsonc
│   └── deploy.toolset.jsonc
└── copilot-instructions.md  # Global rules

Creating Custom Artifacts

Custom Prompt

# Generate a new prompt from template
lv artifact create prompt my-task

# Edit the generated file
code .github/prompts/my-task.prompt.md

Custom Instructions

# Generate new instructions
lv artifact create instructions my-domain

# Specify the scope
lv artifact create instructions my-domain --applyTo "**/domain/**"

Custom Toolset

# Generate a new toolset
lv artifact create toolset my-workflow

# Base it on an existing toolset
lv artifact create toolset my-workflow --extends default

⚠️

Validation

All artifacts are validated on creation and during DevCycle execution. Invalid artifacts will block the cycle with clear error messages.

Next Steps

Explore the CLI Reference for artifact management commands, or learn about Customization strategies for making the framework yours.