Prompt Engineering on KnightLi Blog

Prompt Optimizer: An Open-Source Tool for Prompt Optimization, Testing, and MCP

Fri, 01 May 2026 03:09:07 +0800

Prompt Optimizer is an open-source tool for improving prompts. Its goal is straightforward: help you turn a rough prompt into something clearer, more stable, and easier for large language models to follow.

It is not just a page that “polishes my prompt.” The project provides prompt optimization, result testing, comparison and evaluation, multi-model access, image prompt handling, and MCP integration. For people who often write system prompts, user prompts, and AI workflow templates, it feels more like a dedicated prompt workbench.

What Problem It Solves

Many people run into similar problems when using AI:

Prompts keep getting longer, but output quality does not clearly improve
The same task behaves differently after switching models
System prompts and user prompts are mixed together and hard to debug
After changing a prompt, it is unclear whether the new version is better
Variable templates are useful, but manual replacement and testing are tedious
Prompt optimization should be available to other AI tools, but there is no standard interface

Prompt Optimizer is designed around these problems. It breaks “writing a prompt” into optimization, testing, evaluation, comparison, and iteration, so prompt tuning is no longer based only on intuition.

Main Features

1. Optimize System Prompts and User Prompts

There is more than one kind of prompt.

System prompts usually define roles, goals, boundaries, output rules, and working methods. User prompts are closer to the input for one specific task. When the two are mixed together, the model can miss the key point, and reuse becomes harder.

Prompt Optimizer supports both system prompt optimization and user prompt optimization. You can improve long-term reusable role definitions separately from the input for a specific task.

This is useful for:

Writing rules for AI coding assistants
Designing customer service, reviewer, translation, and analysis roles
Optimizing text-to-image prompts
Turning temporary requirements into reusable templates
Preparing different prompt styles for different models

2. Test and Compare Outputs

Optimizing a prompt is not enough. The important question is whether the optimized prompt actually performs better.

The project supports analysis, single-result evaluation, and multi-result comparison. You can run the original prompt and the optimized prompt on the same task, then compare whether the output is more accurate, stable, and aligned with the goal.

This is more practical than prompts that only “look more professional.” Many prompts look complete on the surface but produce verbose, rigid, or even misdirected output. Comparison testing helps reveal that early.

3. Multi-Model Support

The README says the project supports model services such as OpenAI, Gemini, DeepSeek, Zhipu AI, and SiliconFlow, as well as custom OpenAI-compatible APIs.

This matters because prompt performance depends heavily on the model. The same prompt can behave very differently across models. Multi-model testing helps determine:

Whether the prompt itself is weak
Whether a specific model is unsuitable for the task
Whether different model-specific prompt versions are needed
Whether a smaller model can become usable with a clearer prompt

If you use Ollama locally, or your company has an OpenAI-compatible internal model service, it can also be connected through a custom API.

4. Advanced Testing Mode

The project provides context variable management, multi-turn conversation testing, and Function Calling support.

Variable management is useful for templated tasks. For example, if you have prompts for second-hand sales replies, product descriptions, email responses, code reviews, or document generation, you can replace variables such as product, price, tone, and target user to test different inputs quickly.

Multi-turn conversation testing helps validate long-running dialogue behavior. Many prompts look fine in a single turn, but once follow-up questions begin, they may forget constraints, drift away from the role, or repeat explanations. Multi-turn testing is closer to real usage.

Function Calling support is suitable for more engineering-oriented AI applications. It helps validate model behavior around tool calls, parameter generation, and structured output.

5. Image Generation Prompts

Prompt Optimizer also supports text-to-image and image-to-image workflows. The README mentions integration with image models such as Gemini and Seedream.

Image prompt optimization is different from text tasks. It focuses more on subject, composition, spatial relationship, style, material, lighting, mood, and constraints. Turning a vague idea into a controllable visual description is often more valuable than simply making the prompt longer.

If you often generate product images, covers, illustrations, key visuals, or style references, this type of optimization is useful.

Ways to Use It

The project provides several entry points:

Online version
Vercel self-hosting
Desktop app
Chrome extension
Docker deployment
Docker Compose deployment
MCP Server

The online version is good for quick trials. The project notes that it is a pure frontend app: data is stored locally in the browser and sent directly to AI providers.

The desktop app is better when you need to connect directly to different model APIs. Browser environments can run into CORS limits; the desktop app avoids those issues, especially when connecting to local Ollama or commercial APIs with strict cross-origin policies.

Docker deployment is suitable for your own server or intranet environment. The README gives this basic command:

`1`	`docker run -d -p 8081:80 --restart unless-stopped --name prompt-optimizer linshen/prompt-optimizer`

To configure API keys and access passwords, pass environment variables:

docker run -d -p 8081:80 \
  -e VITE_OPENAI_API_KEY=your_key \
  -e ACCESS_USERNAME=your_username \
  -e ACCESS_PASSWORD=your_password \
  --restart unless-stopped \
  --name prompt-optimizer \
  linshen/prompt-optimizer

If Docker Hub is slow in China, the project also provides an Alibaba Cloud image address in the README.

What MCP Enables

Prompt Optimizer supports Model Context Protocol, or MCP.

When running through Docker, the MCP service can start together with the Web app and be accessed through the /mcp path. This turns it from a Web tool into something that can be called by MCP-compatible apps such as Claude Desktop.

The README lists these MCP tools:

optimize-user-prompt: optimize user prompts
optimize-system-prompt: optimize system prompts
iterate-prompt: perform targeted iteration on an existing prompt

These interfaces are well suited for AI workflows. For example, when writing a complex task prompt, an MCP-compatible client can call the prompt optimization tool directly instead of requiring you to open a Web page and copy text manually.

Difference from Normal Chat Tools

Normal chat tools can also help rewrite prompts, but they usually lack several parts:

Saving and comparing multiple versions is inconvenient
Testing multiple models at once is inconvenient
Turning variables into templates is inconvenient
Multi-turn conversation validation is inconvenient
Integrating through MCP or self-hosting is inconvenient

The value of Prompt Optimizer is that it turns prompt optimization into a repeatable process. It does not just give you a version that “looks more complete”; it lets you keep adjusting prompts around real outputs.

Who Should Use It

This project is worth attention if you:

Often write system prompts
Design roles and output formats for AI applications
Need to compare outputs from different models
Want to turn prompts into reusable templates
Need to test multi-turn dialogue or tool calls
Want to connect prompt optimization to an MCP workflow
Want to deploy a prompt tool locally or inside an intranet

If you only occasionally ask AI a simple question, a normal chat page is enough. This tool is better for people who treat prompts as maintainable assets.

Notes for Use

First, do not treat optimization results as absolutely correct.

Prompt optimization tools can improve expression quality, but they cannot guarantee that a model will never misunderstand. Important tasks still need test cases, manual review, and version comparison.

Second, do not only chase length.

A good prompt is not necessarily longer. It should express goals, boundaries, input and output formats, and evaluation criteria more clearly. Meaningless rule stacking can make the model miss the point.

Third, tune prompts by model.

Different models respond differently to role settings, format constraints, reasoning steps, and examples. A prompt that works well on a large model may not suit a smaller model. Multi-model testing is one reason this tool is useful.

Fourth, consider keys and access control when deploying.

If you deploy it publicly, configure an access password and handle API keys carefully. The project supports access control through environment variables; do not write sensitive configuration directly into public repositories.

Reference

linshenkx/prompt-optimizer

Final Thought

Prompt Optimizer is useful for turning prompts from “a temporary paragraph I wrote by hand” into “a work asset that can be tested, compared, and iterated.”

When you start maintaining prompts across multiple models, scenarios, and versions, this kind of tool is more convenient than a normal chat window.

nuwa-skill: Turning "distilling a person" from an idea into an executable workflow

Wed, 22 Apr 2026 16:20:00 +0800

[alchaincyf/nuwa-skill](https://github.com/alchaincyf/nuwa-skill) can easily make people think of one thing first: using AI to answer in a famous person’s voice. But what makes it genuinely interesting is not whether it sounds convincing. The key is that it tries to turn “distilling how a person thinks” into a repeatable workflow.

If that works, the value goes far beyond a few entertaining character prompts. It means taking someone’s judgment framework, priorities, common heuristics, and communication habits, and turning them into a skill that can be called again and again. What you want is not a sentence that sounds like something a person might say, but something closer to a working interface for “if this person analyzed the issue, what would they look at first, how would they trade things off, and what would they question?”

It solves modeling, not imitation

Many so-called persona prompts are basically just style overlays.

They usually ask the model to:

speak in someone’s tone
quote their signature lines more often
imitate the phrasing they use in public

That looks great in demos, but it often falls apart in real work. The reason is simple: tone is surface-level, while judgment structure is the core. A person is memorable not because they like a few certain words, but because they reliably approach problems in certain ways.

The direction of nuwa-skill is closer to extracting those stable methods. In other words, it cares less about “how to sound like them” and more about “how to think like them.”

A more complete workflow

From the repository description, nuwa-skill aims to build an end-to-end flow: enter a person’s name, then automatically do the research, extraction, and validation, and finally organize the result into a skill that can be used inside Claude Code.

There are several important shifts behind that idea.

First, it assumes the person being distilled does not have to be your coworker. Many people first encounter this kind of idea in the form of “capture how a strong teammate works.” That is valuable, but it is also limited: the sample pool is small, and it usually only covers internal team experience. nuwa-skill expands the target set to a much broader range of people, such as founders, investors, scientists, product managers, and writers.

Second, it emphasizes automation rather than asking the user to handcraft prompts. What really makes this kind of capability practical is not beautiful prompt wording, but whether you can consistently do source gathering, viewpoint synthesis, pattern extraction, and result validation. As soon as any one of those steps depends entirely on manual work, the reuse cost rises quickly.

Third, it tries to make the output a skill rather than a one-off conversation. The former can be reused, combined, and iterated on. The latter usually only works in the current context and falls apart after a few turns.

Why this direction matters

If you treat AI as a question-answering machine, the natural use case is “give me an answer.” But if you treat AI as a workbench, the question becomes “give me a way to look at this problem.”

That is where the value of nuwa-skill leans.

For example, when facing a product decision, what you want may not be one standard answer. You may want several sharply different analytical frames:

one person starts with long-term compounding
one starts with resource constraints
one starts with consistency of user experience
one starts with timing of market entry

If those frames can be packaged reliably, AI stops being “something that writes a paragraph for you” and becomes “something that helps you switch perspectives quickly.” That is much more useful than simply imitating famous quotes, because it directly affects decision quality.

Its most compelling part: turning tacit knowledge into callable assets

Many high-value capabilities are hard to write down as SOPs in the first place.

Why someone consistently judges better than others is often not because they know more explicit rules, but because they have built a tacit filtering system through years of practice:

which signals deserve attention first
which noise should be ignored immediately
which questions should be broken apart
which questions should be inverted
which conclusions must wait for more evidence

This kind of ability is hard to preserve because people cannot always explain it clearly themselves. That is exactly why structured extraction is so valuable. What makes nuwa-skill appealing is that it is not trying to move around surface knowledge. It is trying to reorganize cognitive habits.

Where it fits best

I think this kind of skill is especially useful in a few scenarios.

1. Multi-perspective review before a decision

If you already have a plan but worry that you are only thinking along the path you already know, switching into different “persona perspectives” to review the same issue is more valuable than asking the model to keep expanding your original wording.

2. Learning the judgment framework of a certain kind of expert

Many people learn from experts by collecting quotes, watching interviews, and copying summaries. In the end, they often only remember a few nice lines. Once a thinking pattern becomes a skill, learning becomes much closer to “repeatedly invoking it with real questions” rather than “making a pile of static notes.”

What teams truly lack is often not just documentation, but a shared answer to “how do we usually think when we hit a problem?” If this workflow matures further, it could also be used in reverse to preserve the methods of strong internal operators. It is just clear that the project does not want to limit the idea to internal use cases.

The hard part of projects like this

Of course, an attractive direction does not mean the hard problems are already solved.

The real challenge is never simply installing a skill. It is things like:

whether the sources are reliable enough
whether the extracted patterns are stable rather than illusions from scattered text
whether the model is actually using a person’s framework or merely repeating common impressions
whether the boundaries between different personas will blur inside the model

In other words, the key question is not “can it generate something that sounds plausible?” It is “can the cognitive framework produced by this skill survive reuse across many tasks?” If the project keeps going deeper on validation, its credibility will improve a lot.

Why it goes beyond a prompt template library

In the past, many projects handled this kind of capability as a prompt template library: one persona, one prompt, and the user copies it into a chat. The problem is that a template library is still basically a static asset. It updates slowly, validation is weak, and it is hard to turn it into a complete production workflow.

What nuwa-skill pushes further is that it turns “persona distillation” from a template problem into a workflow problem.

Once the center of gravity shifts from “write a prompt” to “systematically generate, validate, and iterate on a persona skill,” the whole thing starts to look more like engineering than inspiration. For anyone who wants to use it over the long term, that is the more important shift.

Closing

nuwa-skill is interesting not because it turns AI into a celebrity impression show, but because it pushes “how to learn how someone thinks” one step closer to something executable, reusable, and iterable.

If many persona prompts solve “how to talk like someone,” what this project wants to solve is “how to look at problems the way someone does.” The former is great for demos. The latter is much closer to a real productivity tool.

References

GitHub repository: https://github.com/alchaincyf/nuwa-skill
Project README: https://github.com/alchaincyf/nuwa-skill/blob/main/README.md
Skill definition: https://github.com/alchaincyf/nuwa-skill/blob/main/SKILL.md

Karpathy's 65-Line CLAUDE.md: Helping AI Coding Avoid Three Common Mistakes

Sun, 19 Apr 2026 18:27:23 +0800

A GitHub project about AI coding has been getting a lot of attention recently. Its core is not a complex codebase, but a roughly 65-line CLAUDE.md file. The reason it attracted so many stars is not technical complexity. It is that it captures problems many people repeatedly run into when using AI to write code.

The background starts with Andrej Karpathy’s observations on AI coding. Karpathy is an influential educator and engineer in AI: a Stanford PhD, an early OpenAI contributor, and a former Tesla AI leader responsible for Autopilot’s vision system. He has continued to share his views on large models, education, and AI tools, so his comments on changes in programming workflows tend to draw a lot of attention from developers.

He once said that after using Claude Code for a few weeks, his programming style changed noticeably. Previously it was roughly 80% handwritten code and 20% AI assistance. Now it is closer to 80% code written by AI and 20% edits by himself. He described it as “programming in English”, telling an LLM what to write through natural language.

But he also pointed out several recurring problems in AI coding.

01 Wrong Assumptions

The first problem is that models easily make assumptions on behalf of the user, then keep writing along that path. They do not always manage their own confusion, and they do not always stop to ask questions when the requirement is ambiguous.

For example, if the user only says “add a user export feature”, the model might assume it should export all users, output JSON, write to a local file, and skip any confirmation around permissions or fields. Only after the code is done does the user discover that the model’s understanding does not match the real scenario.

A better approach is to list the uncertainties first: should it export all users or filtered results? Should it trigger a browser download or run as a background job? Which fields are needed? How large is the data set? Are there permission constraints? If these questions are not clarified, writing faster only means drifting farther.

02 Over-Complexity

The second problem is that models often turn simple problems into complex ones. A task that could be handled with one function might receive abstract classes, strategy patterns, factory patterns, configuration layers, and a pile of extension points that may never be needed.

This kind of code can look engineered, but in practice it increases maintenance cost. AI is especially good at quickly generating large structures, but it does not always judge whether those structures are necessary. The result is that a task solvable in 100 lines becomes inflated into 1,000 lines.

The test is straightforward: would a senior engineer look at the change and think it is over-designed? If the answer is yes, remove the extra layers and solve the current problem with the least code needed.

03 Collateral Damage

The third problem is that models sometimes modify or delete code they do not fully understand. While fixing a small bug, they may casually change comments, reformat nearby code, clean up imports that look unused, or even touch logic unrelated to the current task.

These “drive-by improvements” are risky because they expand the change scope and make review harder. The user may only want to fix a validator crash caused by an empty email, but the model may also enhance email validation, add username validation, and rewrite docstrings. In the end, it becomes hard to tell which line changed behavior.

A safer rule is: only change what must be changed, and only clean up issues caused by your own change. Existing dead code, formatting problems, or historical baggage should not be touched unless the task explicitly asks for it. At most, mention it.

04 Turning Complaints Into CLAUDE.md

After Karpathy’s comments spread widely, developer Forrest Cheung did something clever: he organized these complaints into executable behavior rules and put them into a CLAUDE.md file.

The project does not contain complicated code. Its key idea is to turn the most failure-prone parts of AI coding into clear working rules. They can be summarized as four principles.

The first is to think before writing. Do not silently assume. Do not hide confusion. If a requirement has multiple interpretations, list them. If there is a simpler approach, say so. Ask when clarification is needed, and push back when needed.

The second is to keep things simple. Do not add features that were not requested. Do not abstract one-off code. Do not add unnecessary configuration. Do not write large amounts of defensive code for extremely unlikely scenarios. If 50 lines can solve it, do not write 200.

The third is to make precise changes. Every changed line should trace directly back to the user’s request. Do not improve nearby code as a side quest. Do not refactor something that is not broken. Match the existing project style as much as possible.

The fourth is goal-driven execution. Do not give the model only a vague instruction. Give it a verifiable success criterion. For example, “fix the bug” can become “write a test that reproduces the bug, then make it pass”; “add validation” can become “write invalid-input tests and make them pass”. The clearer the success criterion, the easier it is for the model to loop toward completion.

05 Why It Took Off

This project became popular not because the content is mysterious, but because it is close to real development work.

Many people using AI for coding have seen similar scenes: the model confidently misunderstands the requirement, the code gets more complex as it goes, or it touches places it should not touch. The value of CLAUDE.md is that it turns those experiences into collaboration rules that can be placed inside a project.

The entry cost is also low: one file can start making a difference, with no complicated integration. Combined with Karpathy’s influence and the project’s practical comparison examples, it naturally spread through the Claude Code user base and the broader AI coding community.

More importantly, these rules are not only for Claude Code. No matter which AI coding tool you use, the underlying issues are similar: the model needs to know when to ask, when to simplify, when to stop, and how to decide that the task is complete.

06 What Developers Can Take Away

The lesson for ordinary developers is simple: AI coding is not about throwing one sentence at a model and waiting for a miracle. The effective approach is to give the model boundaries.

When the requirement is unclear, ask it to expose its assumptions first. When the implementation starts getting complicated, ask it to return to the smallest viable solution. When changing code, keep it focused on the task goal. When finishing work, use tests, commands, or explicit checkpoints to verify the result.

AI is already very capable at writing code, but it still needs good collaboration constraints. The fact that a short CLAUDE.md can attract so much attention shows that developers do not only need smarter models. They also need more reliable ways of working.

In short:

Think before writing to reduce wrong assumptions.
Keep things simple to avoid over-design.
Make precise changes to control change scope.
Work toward goals with verifiable success criteria.

These four rules are not complicated, but they are practical. The prerequisite for AI coding to truly improve efficiency is not making the model write more. It is making it write more accurately, with less code, and under better control.

What Is Agent Skills: From Design Principles to Context Optimization

Sat, 28 Mar 2026 00:00:00 +0000

Agent Skills is a standardized way to package procedural knowledge. In short, it answers not only “whether tools exist” but “how to use them correctly and effectively.”

1. Core Design Principles

The core value of Agent Skills is that it captures reusable methodology:

It provides domain knowledge to guide how agents combine and invoke tools in specific scenarios.
It constrains execution paths, reducing trial-and-error and improving consistency.
It makes complex workflows reusable and iterative, forming stable SOPs over time.

If tool capability is like a hardware interface, Skills is closer to an operations manual plus best-practice playbook, defining what should be done and how.

2. Progressive Disclosure: Solving the Context Bottleneck

The key innovation in Agent Skills is Progressive Disclosure: load information only when needed, instead of pushing everything into the context window at once.

2.1 Layer 1: Metadata

Each skill is usually stored in its own folder, with SKILL.md as the core file. This file starts with YAML front matter that defines basic skill information.

At startup, the agent reads only the front matter of all skills and injects that metadata into the system prompt. In practice:

Metadata for one skill costs about 100 tokens
50 skills cost about 5,000 tokens

2.2 Layer 2: Instructions

When a skill is judged highly relevant to the current task, the agent then reads the full SKILL.md, loading detailed instructions, notes, and examples.

Token usage at this layer depends on instruction complexity, typically:

1,000 to 5,000 tokens

2.3 Layer 3: Additional Resources (Scripts & References)

For more complex skills, SKILL.md can reference scripts, config files, and docs, which are loaded only when needed.

Example directory structure:

skills/pdf-processing/
├── SKILL.md                 # Main skill file
├── parse_pdf.py             # PDF parsing script
├── forms.md                 # Form-filling guide (loaded only for form tasks)
└── templates/
    ├── invoice.pdf
    └── report.pdf

Typical invocation pattern:

Run parse_pdf.py when PDF parsing is required
Load forms.md only for form-filling tasks
Access template files only when generating specific output formats

3. Why This Design Works

3.1 Scalable Knowledge Capacity

With scripts and external files, a skill can carry knowledge far beyond context-window limits. For example, a data-analysis skill can include a 1GB dataset plus query scripts, and the agent can access data through execution instead of loading the whole dataset into context.

3.2 Stronger Determinism

Delegating complex computation, data transformation, and format parsing to code significantly reduces uncertainty and hallucination risk in pure text generation.

4. Practical Impact: From 16k to 500 Tokens

Community practice shows that Progressive Disclosure can drastically reduce initial context overhead:

Traditional MCP approach: directly connect to an MCP server with many tool definitions, around 16,000 tokens at initialization
With Skills packaging: use a lightweight gateway skill described mainly in front matter, around 500 tokens at initialization

Detailed instructions and additional resources are loaded only when the task truly requires them. This lowers initial cost and improves context management precision during the conversation.

Summary

The key value of Agent Skills is upgrading from “tools are available” to “capabilities are reusable.” With Progressive Disclosure, systems can preserve capability depth while significantly optimizing token cost and execution stability.

How Non-Programmers Can Direct AI to Do the Work: Extracting Diagrams and Math Formulas from an Image (Hands-On Example)

Thu, 26 Mar 2026 00:00:00 +0000

Prerequisites

Install VS Code and the Codex extension. You can refer to this article.
Using these tools does not require programming experience. In this workflow, VS Code is mainly for organizing files; you describe your goal, and AI writes and runs the code for you.
This post records the full process to spark ideas and help more people discover practical ways to use AI.

Goal

Prepare an image that contains both math formulas and illustrative diagrams:

We want to achieve three things:

Split diagrams into clean, separate images.
Recognize formulas and convert them to LaTeX for easier editing.
Link each diagram to its corresponding formula.

Process

First, recognize the image, generate a Markdown document, and convert formulas to LaTeX

Conversion result:

# 1.png Recognition Result

## Geometry Formulas (LaTeX)

1. Triangle area (side lengths and circumradius):

$$
S = \frac{abc}{4R}
$$

2. Triangle area (inradius and semiperimeter):

$$
S = pr
$$

3. Frustum volume:

$$
V = \frac{\pi\left(r^2 + Rr + R^2\right)h}{3}
$$

4. Frustum lateral surface area:

$$
S = \pi a(R + r)
$$

5. Cylinder volume:

$$
V = \pi r^2 h
$$

6. Cylinder lateral surface area:

$$
S = 2\pi rh
$$

7. Sphere volume:

$$
V = \frac{4}{3}\pi R^3
$$

8. Sphere surface area:

$$
S = 4\pi R^2
$$

9. Law of sines:

$$
\frac{a}{\sin A}=\frac{b}{\sin B}=\frac{c}{\sin C}=2R
$$

10. Law of cosines:

$$
a^2=b^2+c^2-2bc\cos A
$$

$$
b^2=a^2+c^2-2ac\cos B
$$

$$
c^2=a^2+b^2-2ab\cos C
$$

All formulas were recognized, and AI even added formula names automatically, which is great. However, the small diagram crops were not generated yet.

Try asking AI to crop the image

# 1.png Recognition Result (side-by-side layout with refined cropping)

<table>
  <tr>
    <td>![](crops/01_triangle_circum.png)</td>
    <td>

$$
S = \frac{abc}{4R}
$$

</td>
  </tr>
  <tr>
    <td>![](crops/02_triangle_incircle.png)</td>
    <td>

$$
S = pr
$$

</td>
  </tr>
  <tr>
    <td>![](crops/03_frustum.png)</td>
    <td>

$$
V = \frac{\pi\left(r^2 + Rr + R^2\right)h}{3}
$$

$$
S = \pi a(R + r)
$$

</td>
  </tr>
  <tr>
    <td>![](crops/04_cylinder.png)</td>
    <td>

$$
V = \pi r^2 h
$$

$$
S = 2\pi rh
$$

</td>
  </tr>
  <tr>
    <td>![](crops/05_sphere.png)</td>
    <td>

$$
V = \frac{4}{3}\pi R^3
$$

$$
S = 4\pi R^2
$$

</td>
  </tr>
  <tr>
    <td>![](crops/06_laws.png)</td>
    <td>

$$
\frac{a}{\sin A}=\frac{b}{\sin B}=\frac{c}{\sin C}=2R
$$

$$
a^2=b^2+c^2-2bc\cos A
$$

$$
b^2=a^2+c^2-2ac\cos B
$$

$$
c^2=a^2+b^2-2ab\cos C
$$

</td>
  </tr>
</table>

Result: The diagrams were cropped and placed in matching positions, but the crops still include noise from nearby areas.

Fix over-cropping: keep the full target area first, then manually remove extra parts
The output is still inconsistent at this step. It is not yet clear whether the issue comes from prompting or model variability in visual localization.

Summary

Using Codex feels different from chatting directly on chatgpt.com.
On chatgpt.com, it often feels like AI is guiding your work; in Codex, it feels more like AI is executing your instructions.
After you describe your requirement, AI can generate code, run it, and complete the task. The feeling is that you are directing AI to do the work.
This process does not require strong programming skills, and non-programmers can still get real results step by step.

Prompt Engineering on KnightLi Blog

Prompt Optimizer: An Open-Source Tool for Prompt Optimization, Testing, and MCP

What Problem It Solves

Main Features

1. Optimize System Prompts and User Prompts

2. Test and Compare Outputs

3. Multi-Model Support

4. Advanced Testing Mode

5. Image Generation Prompts

Ways to Use It

What MCP Enables

Difference from Normal Chat Tools

Who Should Use It

Notes for Use

Reference

Final Thought

nuwa-skill: Turning "distilling a person" from an idea into an executable workflow

It solves modeling, not imitation

A more complete workflow

Why this direction matters

Its most compelling part: turning tacit knowledge into callable assets

Where it fits best

1. Multi-perspective review before a decision

2. Learning the judgment framework of a certain kind of expert

3. Sharing an analytical style across a team

The hard part of projects like this

Why it goes beyond a prompt template library

Closing

References

Karpathy's 65-Line CLAUDE.md: Helping AI Coding Avoid Three Common Mistakes

01 Wrong Assumptions

02 Over-Complexity

03 Collateral Damage

04 Turning Complaints Into CLAUDE.md

05 Why It Took Off

06 What Developers Can Take Away

What Is Agent Skills: From Design Principles to Context Optimization

1. Core Design Principles

2. Progressive Disclosure: Solving the Context Bottleneck

2.1 Layer 1: Metadata

2.2 Layer 2: Instructions

2.3 Layer 3: Additional Resources (Scripts & References)

3. Why This Design Works

3.1 Scalable Knowledge Capacity

3.2 Stronger Determinism

4. Practical Impact: From 16k to 500 Tokens

Summary

How Non-Programmers Can Direct AI to Do the Work: Extracting Diagrams and Math Formulas from an Image (Hands-On Example)

Prerequisites

Goal

Process

Summary