# LangGPT: a prompt template that argues it has been absorbed into the models

> A prompt engineering framework from the Chinese AI community whose central claim is that major models already know its structure, so you can invoke it by name.

**langgptai/LangGPT** — LangGPT: empowering everyone to become a prompt expert. Originator of structured prompts and meta-prompts, and the most popular framework for prompt engineering. 10,000+ stars, battle-tested by thousands of users worldwide. Created by Yunzhong Jiangshu.

- Repository: https://github.com/langgptai/LangGPT
- Website: https://github.com/langgptai
- Stars: 12,585 · Forks: 949
- Language: Jupyter Notebook
- License: Apache-2.0
- Published: 2026-10-07 · Updated: 2026-10-07 · Language: en
- Canonical page: https://hysenlabs.com/projects/langgptai-langgpt

## The central claim, stated plainly

The README makes an argument that is different from the usual framework pitch. LangGPT is described as a structured, reusable prompt design framework, and as a kind of programming language for prompts, systematic, template-based and scalable.

Then comes the part that distinguishes it. The claim is that it is the most popular and most widely adopted structured prompt paradigm in the Chinese AI community, proposed by Yunzhong Jiangshu in 2023, and that it has been learned so deeply into major language models that when a model speaks LangGPT it is no longer because you taught it, because it already knows. The README pushes this further with the line that the finest fate of a paradigm is to no longer need its name remembered, having become the model's mother tongue.

Practically, that claim translates into the simplest usage method offered. Say write me a prompt the LangGPT way, or ask for Yunzhong Jiangshu's structured-prompt style, or ask for a LangGPT-style structured prompt, and the model produces one. The keywords LangGPT, Yunzhong Jiangshu and structured prompt are described as triggers.

Whether a model responds this way is not something the repository demonstrates. There is no evaluation here, no test suite and no comparison against other frameworks, so the claim stands on adoption: 12,520 stars and 946 forks.

## The template itself, section by section

The core template is given in full, and it is short enough to read in a minute. The structure is:

```markdown
# Role: Your_Role_Name

## Profile
- Author: YourName
- Version: 1.0
- Language: English
- Description: Clear role description and core capabilities

## Goal
- Outcome: What concrete result/outcome should be delivered for the user/session
- Done Criteria: Clear acceptance criteria (how we know it’s finished and good)
- Non-Goals: What is explicitly out of scope to avoid scope creep
```

Six sections carry the idea: Role, Profile, Goal, Rules, Workflow and Initialization. Profile holds metadata about the role and its author. Goal splits into Outcome, Done Criteria and Non-Goals, and the Non-Goals line is the interesting one, since it is an explicit scope boundary rather than a description of what to do.

Skills come next, numbered as `### Skill-1` with a description and expected behavior and output per skill, so a role with several capabilities gets one block each. Rules holds constraints such as not breaking character under any circumstance and not making up facts. Workflow is a numbered procedure, typically analyze the input and identify intent, apply relevant skills systematically, deliver structured output.

The closing Initialization block is the part that makes the prompt operational rather than descriptive: it instructs the model that as a given role it must follow the Rules, talk in a default Language, greet the user, then introduce itself and introduce the Workflow. That is a bootstrap rather than a description, and it is the piece most hand-written prompts omit.

## Five ways in, and they are not equivalent

The README lists five methods, and they differ enormously in reliability.

Method one is triggering by name, with no template at all, which depends entirely on the model's training. Method two is automated tools: a full-featured GPT-4 generator, a Kimi+ integration for Moonshot Kimi users, and PromptGPT as a lighter GPT-3.5 version.

Method three is mastering the template, with prerequisites stated as basic Markdown knowledge and GPT-4 or Claude recommended. Method four is starting from an example library hosted on Feishu, described as a library of proven templates to adapt.

Method five is the one with the most engineering around it, a Claude Code skill. Installation through the official marketplace takes two commands:

```bash
/plugin marketplace add langgptai/claude_marketplace
/plugin install structured-prompt-writer@langgpt
```

Manual installation means downloading `langgpt.skill` from the repository's releases, extracting it to `~/.claude/skills/`, and typing `/langgpt` in Claude Code. The listed skill features are structured prompt templates covering Role, Profile, Skills, Rules and Workflow, a rich example library including FitnessGPT, Poet, Xiaohongshu Master and Name Master, advanced techniques using variables, commands and conditional logic, and a model compatibility guide for GPT-4, Claude and GPT-3.5.

Method five is the only one that installs anything, which makes it the most verifiable of the five. The skill file is in the repository tree as `langgpt.skill`, and the same marketplace reportedly ships further skills by the same author, including `awesome-design-html` with brand-themed design references, `cto`, and `mind-clone`.

## Academic framing and where the original writing lives

There is a paper, linked as arXiv:2402.16929, with a Chinese version at `Papers/LangGPT_paper_cn.md` in the repository. The README presents it as an academic foundation rather than an afterthought, which is unusual for a prompt framework and explains why the repository has a `Papers/` directory at all.

The `Docs/` directory is arguably more distinctive. The README lists essays with titles such as the dynamics of human-AI dialogue, five types of rationality in prompt design, mirror tendencies in LLM behavior, statistical gravity well and edge expression, the essence of prompts, a results-oriented method for writing prompts, AI consciousness, and fragments on AI-native organisational thinking.

Two of those titles hint at a thesis rather than a set of tips. One argues for machines optimising while humans define the criteria, and another covers how prompts, agents and a world where software is no longer silent relate to each other. These are essays in Chinese, and they are not translated in the repository, which has `README.md`, `README_zh.md` and `README_ja.md` but no English versions of `Docs/`.

For an English-speaking reader this is the practical limit of the project. The template, the skill and the paper are accessible; the theoretical material is not translated, and it is the part where the framework's actual argument lives rather than its syntax.

## Repository contents and a license discrepancy

The tree shows a documentation project rather than a code one: `README.md` with Chinese and Japanese siblings, `Docs/`, `Papers/`, `Prompts/`, `PromptShow/`, `LangGPT/`, `examples/`, `imgs/`, `src/` and `langgpt.skill`. The repository language is reported as Jupyter Notebook, which reflects that the example material is notebooks rather than that there is a library to call.

The `examples/` directory is the substantive part and it is well populated: a custom fitness plan, a Chinese poet, a Xiaohongshu writer, a code assistant, math tutors, and markdown collections including `prompts_en.md`, `prompts_zh.md`, `prompts_gpt3.5_zh.md`, a community-submitted collection and a data analysis example.

One discrepancy is worth resolving before you rely on the project commercially. The repository metadata reports the license as Apache-2.0, while the README badge at the top of the page reads `license-MIT-blue`. There is a `LICENSE` file in the tree, and the README badge points at it, so the file is the place to check which grant actually applies. Given the ambiguity, treating the terms as unsettled is the safe reading.

The last push to `main` was 2026-09-11, and there are no GitHub releases, so version history for the skill file is not visible from the repository itself even though the manual install instructions point at the releases page for `langgpt.skill`.

## Assessing this against ordinary prompt writing

The honest comparison is not against other prompt frameworks, since there is no measured comparison here, but against writing a prompt yourself.

What the template gives you for free is structure and a vocabulary. Naming a role, separating outcome from acceptance criteria from non-goals, listing rules apart from skills, and writing a bootstrap instruction are all things a careful person does anyway. Written down once, they become a checklist rather than a habit.

Where it is weakest is that it is a template. The `### Skill-1` numbering in the README example is a placeholder, and filling five numbered blocks does not produce a good role any more than filling in a form does. The value scales with how much domain knowledge you put in, which is the same for any prompt approach.

The strongest practical argument for it is the skill file, because a Claude Code skill is a repeatable, installable artefact rather than a document you re-read. The weakest is Method one, since a name-trigger depends on training data nobody in this repository controls.

The star count deserves context rather than admiration. 12,520 stars and 946 forks in a project that is mostly Markdown indicates a very large audience, not a widely integrated dependency. Nothing here needs to be adopted for your application to build, and nothing breaks if you stop using it.

## Conclusion

LangGPT is unusual among prompt frameworks in making its own adoption the argument: the README's position is not that the template is good but that the models have learned it well enough to produce it on request. That is either the strongest possible endorsement or an unfalsifiable one, and the repository does not offer benchmarks to settle it, only examples. What you can evaluate directly is the template itself, which is short, structured like a program, and uses the same conceptual vocabulary, so it is at worst a good starting skeleton. Note the licensing detail: the repository reports Apache-2.0 while the README badge reads MIT, and the `LICENSE` file is the place to check. The `Docs/` essays on dialogue dynamics and rationality are the more original material here, and the Claude Code skill is the most concrete way to install it.

## FAQ

### What is LangGPT used for?

Writing structured prompts for large language models. The framework organises a prompt into Role, Profile, Goal, Rules, Workflow and Initialization sections so a role definition is reusable and its constraints are explicit. It can be used as a template you fill in, as a Claude Code skill you install, or invoked by name in a model that has learned the pattern.

### Who created LangGPT?

It was proposed by Yunzhong Jiangshu in 2023, and the repository is maintained under the `langgptai` organisation. The README credits the same author for the Claude Code marketplace skills, including the structured prompt writer and several others listed by name.

### What sections does the basic LangGPT template have?

Six. Role names the role, Profile carries metadata and a description, Goal splits into Outcome, Done Criteria and Non-Goals, Skills are numbered blocks with expected behavior, Rules holds constraints such as not breaking character, Workflow is a numbered procedure, and Initialization is the bootstrap that makes the model greet the user and introduce the workflow.

### What license does LangGPT use?

The sources disagree. The repository metadata reports Apache-2.0 while the README badge reads MIT, and the badge links to a `LICENSE` file in the tree. Since the two are different grants with different obligations, read that file directly rather than relying on either the badge or the metadata field.

## Sources

- [Issues](https://github.com/langgptai/LangGPT/issues)
- [langgptai/LangGPT on GitHub](https://github.com/langgptai/LangGPT)
- [License: Apache-2.0](https://github.com/langgptai/LangGPT/blob/main/LICENSE)
- [Project website](https://github.com/langgptai)
- [README](https://github.com/langgptai/LangGPT/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/langgptai-langgpt