How do I install the Code Generation skill?

Run npx skillmds@latest add motlin/code-generation in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

Is Code Generation safe to use?

This skill has not completed SkillMD's automated safety review yet. Capability flags: docs only. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Code Generation?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Code Generation free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Code Generation?

motlin (@motlin) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Code Generation by motlin — Agent Skill

Name: Code Generation
Rating: 4.5 (4 reviews)
Author: motlin

Code Generation

This skill should be used when the user asks to "fix formatter-off", "fix code generation formatting", "fix auto-formatted string concatenation", "add formatter off", or when writing, reviewing, or generating Java code generators that build source code via string concatenation. Also applies proactively when creating new code generation methods or modifying existing ones — always use @formatter:off guards and the one-output-line-per-source-line convention.

motlin Updated Sep 10, 2026

File contents

Code Generation Formatting

Purpose

Java code generators that build source code via string concatenation must use // @formatter:off / // @formatter:on guards. Without these, IntelliJ's auto-formatter breaks concatenation chains across multiple lines, destroying the correspondence between Java source lines and generated output lines.

The Rule

Each line of generated output (terminated by \n) must occupy a single Java source line. A new line in the Java source should only occur where there is a \n in the template string.

Bad (auto-formatted)

setterBody = ""
    + "            domainObject.get"
    + propNameUpper
    + "().clear();\n"
    + "            return;\n";

Good (one output line per Java line)

// @formatter:off
setterBody = ""
        + "            domainObject.get" + propNameUpper + "().clear();\n"
        + "            return;\n";
// @formatter:on

How to Identify Violations

Search for string concatenation blocks that contain \n literals but are NOT wrapped in // @formatter:off. Common patterns:

Multi-line + chains where each + is on its own line and template variables are separated from their surrounding string literals
.collect() lambdas producing single-line templates that got broken across multiple lines
Return statements wrapped in parentheses return ( "" + ... ) instead of direct return "" + ...

Fix Procedure

Search generator files for string concatenation containing \n that lacks @formatter:off guards
For each violation:
- Add // @formatter:off before the block
- Collapse string concatenation so each \n-terminated segment is on one Java source line
- Add // @formatter:on after the block
For .collect() lambdas that produce single-line templates (one \n), collapse the entire template string onto one line
For multi-line templates, each \n-terminated segment gets its own line with + continuation
Use the same indentation style as existing @formatter:off blocks in the file

Indentation Style

Match the existing convention in each file. The typical pattern uses tabs with + aligned:

		// @formatter:off
		// language=JAVA
		return ""
				+ "package " + packageName + ";\n"
				+ "\n"
				+ "public class " + className + "\n"
				+ "{\n"
				+ "}\n";
		// @formatter:on

For .collect() lambdas with single-line output, keep it all on one line:

		// @formatter:off
		String fields = properties
			.collect((p) -> "    public final " + this.getType(p) + " " + p.getName() + ";\n")
			.makeString("");
		// @formatter:on

Additional Markers

When the string block contains valid Java source, add // language=JAVA after // @formatter:off to enable IntelliJ language injection for syntax highlighting inside the strings.

---name: code-generationdescription: This skill should be used when the user asks to "fix formatter-off", "fix code generation formatting", "fix auto-formatted string concatenation", "add formatter off", or when writing, reviewing, or generating Java code generators that build source code via string concatenation. Also applies proactively when creating new code generation methods or modifying existing ones — always use @formatter:off guards and the one-output-line-per-source-line convention.---# Code Generation Formatting## PurposeJava code generators that build source code via string concatenation must use `// @formatter:off` / `// @formatter:on` guards. Without these, IntelliJ's auto-formatter breaks concatenation chains across multiple lines, destroying the correspondence between Java source lines and generated output lines.## The RuleEach line of generated output (terminated by `\n`) must occupy a single Java source line. A new line in the Java source should only occur where there is a `\n` in the template string.### Bad (auto-formatted)```javasetterBody = "" + " domainObject.get" + propNameUpper + "().clear();\n" + " return;\n";```### Good (one output line per Java line)```java// @formatter:offsetterBody = "" + " domainObject.get" + propNameUpper + "().clear();\n" + " return;\n";// @formatter:on```## How to Identify ViolationsSearch for string concatenation blocks that contain `\n` literals but are NOT wrapped in `// @formatter:off`. Common patterns:1. **Multi-line `+` chains** where each `+` is on its own line and template variables are separated from their surrounding string literals2. **`.collect()` lambdas** producing single-line templates that got broken across multiple lines3. **Return statements** wrapped in parentheses `return ( "" + ... )` instead of direct `return "" + ...`## Fix Procedure1. Search generator files for string concatenation containing `\n` that lacks `@formatter:off` guards2. For each violation: - Add `// @formatter:off` before the block - Collapse string concatenation so each `\n`-terminated segment is on one Java source line - Add `// @formatter:on` after the block3. For `.collect()` lambdas that produce single-line templates (one `\n`), collapse the entire template string onto one line4. For multi-line templates, each `\n`-terminated segment gets its own line with `+` continuation5. Use the same indentation style as existing `@formatter:off` blocks in the file## Indentation StyleMatch the existing convention in each file. The typical pattern uses tabs with `+` aligned:```java // @formatter:off // language=JAVA return "" + "package " + packageName + ";\n" + "\n" + "public class " + className + "\n" + "{\n" + "}\n"; // @formatter:on```For `.collect()` lambdas with single-line output, keep it all on one line:```java // @formatter:off String fields = properties .collect((p) -> " public final " + this.getType(p) + " " + p.getName() + ";\n") .makeString(""); // @formatter:on```## Additional MarkersWhen the string block contains valid Java source, add `// language=JAVA` after `// @formatter:off` to enable IntelliJ language injection for syntax highlighting inside the strings.

Frequently asked questions