# Art-Direct ImageGen

Concept-first art direction for AI image generation.

> **Radical shell. Conservative semantics.**

`art-direct-imagegen` is a portable [Agent Plugin](https://agent-plugins.org/) that develops the visual idea before asking an image model to render it. It protects supplied content, product behavior, and critical copy while keeping composition and visual language open enough for genuine design judgment.

Use it when a request is vague, taste-heavy, structurally dense, or producing generic results. Skip it for fixed surgical edits such as background removal or changing one named object.

## Install

Repository:

```text
https://github.com/akenoowww/art-direct-imagegen-plugin
```

### GitHub Copilot CLI

Install directly from GitHub:

```bash
copilot plugin install akenoowww/art-direct-imagegen-plugin
```

Verify:

```bash
copilot plugin list
```

See the [Copilot CLI plugin reference](https://docs.github.com/en/copilot/reference/copilot-cli-reference/cli-plugin-reference).

### Visual Studio Code

1. Open the Command Palette.
2. Run **Chat: Install Plugin From Source**.
3. Paste the repository URL above.
4. Open **Extensions → Agent Plugins** to verify that the plugin is enabled.

VS Code supports root-level Agent Plugins manifests and direct Git installs. See [Agent plugins in VS Code](https://code.visualstudio.com/docs/agent-customization/agent-plugins).

### Kiro

1. Open the **Powers** panel.
2. Select **Add Custom Power**.
3. Choose **Import power from GitHub**.
4. Paste the repository URL.

See [Create and share Kiro Powers](https://kiro.dev/docs/powers/create/#sharing-your-power).

### Cursor

For a local user installation:

```bash
mkdir -p ~/.cursor/plugins/local
git clone https://github.com/akenoowww/art-direct-imagegen-plugin.git \
  ~/.cursor/plugins/local/art-direct-imagegen
```

Then open **Customize** and verify that `art-direct-imagegen` appears under skills. Teams can import the repository through a Cursor team marketplace. See [Cursor Plugins](https://cursor.com/docs/plugins).

### ChatGPT and Codex

Codex currently installs plugins from the universal Plugins Directory or a configured marketplace, not directly from an arbitrary plugin Git URL.

Until this plugin is published in the universal directory or a hosted marketplace, add it to the automatically discovered personal marketplace at:

```text
~/.agents/plugins/marketplace.json
```

If the file does not exist, create it with:

```json
{
  "name": "personal",
  "interface": {
    "displayName": "Personal"
  },
  "plugins": [
    {
      "name": "art-direct-imagegen",
      "source": {
        "source": "url",
        "url": "https://github.com/akenoowww/art-direct-imagegen-plugin.git",
        "ref": "main"
      },
      "policy": {
        "installation": "AVAILABLE",
        "authentication": "ON_INSTALL"
      },
      "category": "Productivity"
    }
  ]
}
```

If the file already exists, keep its current contents and append only the plugin object to its existing `plugins` array.

Install from the personal marketplace:

```bash
codex plugin add art-direct-imagegen@personal
```

For ChatGPT Desktop, restart the app, open **Plugins**, select **Personal**, and install **Art-Direct ImageGen**. Start a new task after installation so the new skill is discovered. See [Package and distribute OpenAI plugins](https://developers.openai.com/plugins/build/plugins).

If you only need the standalone Codex skill and not the plugin package, the original skill repository remains available:

```bash
git clone https://github.com/akenoowww/art-direct-imagegen.git \
  ~/.codex/skills/art-direct-imagegen
```

## Quick start

Invoke the skill by name and describe the visual problem:

```text
Use $art-direct-imagegen.

Redesign the attached interface into a distinctive visual direction. Preserve
the supplied content, user jobs, actions, and evidenced states. You may rethink
the information architecture, but do not invent product behavior or data.
Generate the minimum complete set of separate images needed to show the flow.
```

Cross-client wording that does not rely on invocation syntax:

```text
Use the art-direct-imagegen skill to develop and challenge several genuinely
different concepts, select one direction, and prepare a focused image prompt.
```

Other useful starting requests:

- “Turn this vague campaign idea into one memorable visual system.”
- “The previous generations look generic. Re-branch from a different concept.”
- “Redistribute this dense interface across the minimum necessary states.”
- “Keep the product semantics, but radically rethink its visual shell.”

## What it does

- Extracts a global contract using `LOCK / GUIDE / FREE / FORBID`.
- Labels input images as functional references, style references, edit targets, or visual-system anchors.
- Develops at least three semantically different concepts for substantial creative work.
- Selects a direction through thesis, antithesis, and synthesis.
- Maps dense content across screens, drawers, modals, tabs, or scroll states before prompting.
- Compiles one deliberately focused prompt per asset or visible state.
- Rejects invented product facts, controls, outcomes, and unsupported states.
- Evaluates generated results and abandons concepts that repeatedly produce generic work.

It is an art-direction and information-architecture workflow, not merely a prompt expander.

## When to use it

Use the full workflow for:

- conceptual or radical visual redesigns;
- vague or judgment-heavy image requests;
- dense UI screenshots with related interaction states;
- coherent campaigns or sets of related assets;
- repeated generic, literal, or template-like generations;
- prompts that have become long and geometrically prescriptive.

Use the host client's image-generation workflow directly for:

- background removal;
- replacing one named object;
- preserving everything except one explicit edit;
- literal transformations whose creative solution is already fixed.

## How it works

```text
source role
    → global contract
    → predictable-answer quarantine
    → concept branching by mechanism
    → dialectical selection
    → output manifest
    → one prompt per state
    → artifact evaluation and iteration
```

### Preserve meaning, not the old layout

The skill separates the request into:

- `LOCK`: supplied functions, content, actions, states, platform facts, and critical copy;
- `GUIDE`: feeling, hierarchy, tension, and product posture;
- `FREE`: composition, grouping, typography character, palette nuance, geometry, and material language;
- `FORBID`: invented semantics, misleading affordances, known failure modes, and explicit prohibitions.

A source screenshot's layout is not automatically locked. The visual shell may change radically while its product meaning remains intact.

### Branch concepts by mechanism

Candidate directions must differ in organizing logic, not only color, typeface, or decoration. The skill explores mechanisms such as behavior, information relationships, time, material logic, inversion, spatial metaphor, and scale shift.

Each serious candidate is attacked before selection:

- Why is it specific and memorable?
- How could it become decorative, confusing, derivative, or unusable?
- Can that weakness be removed without killing the idea?

### Architect dense outputs before prompting

Every supplied item is mapped to one of three destinations for each output:

- `NOW`: visible in the current asset or state;
- `ELSEWHERE`: preserved in another named output or scroll position;
- `UNSUPPORTED`: not supplied and therefore not rendered or inferred.

The skill generates separate final states rather than compressing a complete interaction flow into an unreadable collage. Once the first output is accepted, it becomes the visual-system anchor for later outputs.

### Keep renderer prompts open

A compiled prompt normally contains one visible state, one immediate user job, one non-geometric concept relationship, a few critical labels, and no more than three causal failure modes.

The global inventory, rejected concepts, long-form reasoning, and content assigned elsewhere stay outside the renderer prompt. If the same concept produces two generic structural results, the skill changes concepts instead of dictating a wireframe.

## Runtime compatibility

The package follows [Agent Plugins 1.0](https://agent-plugins.org/specification) and contains one portable [Agent Skill](https://agentskills.io/specification).

The plugin does **not** bundle an image model or MCP server. Its final rendering step requires the host client to expose `imagegen` or an equivalent image-generation tool. In a client without such a tool, the planning, concept selection, critique, and prompt compilation stages still work, but rendering must be performed separately.

## Safety and package contents

This repository contains:

- Markdown instructions and references;
- one portable `plugin.json` manifest;
- one Codex compatibility manifest;
- OpenAI display metadata;
- an MIT license.

It contains no MCP servers, hooks, executable scripts, bundled binaries, credentials, or network endpoints. Review community plugins before installation even when they contain no executable components.

## Package structure

```text
art-direct-imagegen-plugin/
├── plugin.json
├── .codex-plugin/
│   └── plugin.json
├── LICENSE
├── README.md
└── skills/
    └── art-direct-imagegen/
        ├── SKILL.md
        ├── agents/
        │   └── openai.yaml
        └── references/
            ├── concept-planning.md
            ├── evaluation.md
            ├── flow-architecture.md
            └── prompt-compilation.md
```

The portable manifest is [`plugin.json`](plugin.json). The skill entrypoint is [`skills/art-direct-imagegen/SKILL.md`](skills/art-direct-imagegen/SKILL.md).

## Update

Use the update mechanism of the client that installed the plugin. For a local Git clone:

```bash
git -C /path/to/art-direct-imagegen-plugin pull
```

For the standalone Codex skill installation:

```bash
git -C ~/.codex/skills/art-direct-imagegen pull
```

Start a new agent task after updating so the client reloads the skill definition.

## Validation

Validate the skill when the system `skill-creator` tools are available:

```bash
python3 ~/.codex/skills/.system/skill-creator/scripts/quick_validate.py \
  ./skills/art-direct-imagegen
```

Release checks should also confirm:

- the root manifest validates against the Agent Plugins 1.0 schema;
- the Codex compatibility manifest validates as a native plugin;
- all relative reference links resolve;
- no private paths, screenshots, generated images, or credentials are present;
- the packaged skill remains identical to its source repository.

## Limitations

- Generated bitmap UI is visual direction, not implementation proof.
- Image generation cannot guarantee perfect long-form text rendering.
- Complex multi-state work requires multiple generation calls.
- Stronger concept planning improves the odds of a distinctive result but cannot guarantee aesthetic success from every renderer call.

## Contributing

Keep examples universal and repository-safe. Do not commit private prompts, client screenshots, generated outputs, local absolute paths, credentials, or project-specific copy.

Contributions should preserve the central rule: protect product semantics while leaving the visual solution open.

## License

MIT. See [LICENSE](LICENSE).