AI编程 on KnightLi Blog

How to use DeepSeek-Reasonix? DeepSeek native terminal programming agent

Sat, 06 Jun 2026 22:26:00 +0800

esengine/DeepSeek-Reasonix is a terminal-oriented AI programming agent. It is different from many “CLIs with a layer of OpenAI API”. The project is positioned as DeepSeek-native: designed around the stability of DeepSeek’s prefix cache, making long sessions cheaper and more suitable for always-on work.

The description in the README is very straightforward: a config- and plugin-driven harness, a single static Go binary, and models, agents, tools and plug-ins are all declared in reasonix.toml.

What problem does it solve?

There are many terminal programming agents now, but the common problems are also obvious:

The configuration is hard-coded and it is inconvenient to change the model;
The tool access method is not uniform;
In long sessions, the prompt keeps changing and the cache hit rate is poor;
Each mission is restarted, and the token cost is high;
I want to use DeepSeek, but the existing tools may not be optimized according to the characteristics of DeepSeek.

The focus of Reasonix is not “yet another chat CLI”, but rather using DeepSeek’s prefix cache as the centerpiece of its design. If the prefix is stable in a long session, cache hits are better, and the cost and speed will be more controllable.

Core Design

Several features listed in the project README are worthy of attention:

Config-driven: provider, agent, tools, and plugins are all configured through reasonix.toml;
Multi-model: DeepSeek flash/pro and MiMo have presets, and can also be connected to any OpenAI-compatible endpoint;
Composable: allows the two models of executor and planner to divide the work;
Plugin-driven: External tools are accessed through the stdio JSON-RPC sub-process, compatible with MCP ideas;
Built-in tools: built-in tools self-register during compilation;
Single static Go binary: Simple to deploy, no need to drag a bunch of runtimes.

For those who like to put the development environment in the terminal, this direction is very refreshing. The configuration file is the console, and the plug-in is the capability boundary.

Suitable for how to use

Reasonix is more suitable for these scenarios:

You are already using DeepSeek for coding tasks;
I hope there is a resident programming agent in the terminal;
Want to optimize long session costs around prefix cache;
Want to combine tools and plug-ins through configuration;
Want to use OpenAI-compatible endpoint to switch between different models;
Like Go’s single-file binary deployment approach.

It’s not necessarily suitable for users who don’t touch the terminal at all. If you prefer the built-in IDE experience, Cursor, Copilot, or Claude Code may be more convenient. Reasonix’s temperament is more of an engineer’s toolbox: configuration, plug-ins, terminal, long sessions.

The difference between ## and Claude Code / Codex

Tools such as Claude Code and Codex are more like complete products, while Reasonix is more like a configurable Agent harness.

You can understand it this way:

Tools	What is more like	Who is it suitable for
Claude Code / Codex	Out-of-the-box programming Agent	People who want to complete tasks quickly
Cursor	AI development environment within IDE	Heavy graphical interface and project editing users
DeepSeek-Reasonix	Agent framework for DeepSeek and endpoint workflows	People who want to control configuration, tools and costs

The advantage of Reasonix is controllability and DeepSeek optimization, but the price is that you need to understand the configuration and plug-ins, and you won’t have to do it bit by bit like a commercial IDE.

Think clearly before using

The stronger the terminal programming agent’s ability, the greater the risk:

There must be boundaries for file reading and writing, command execution and network access;
The source of the plug-in must be trustworthy;
Long session caching is not permission isolation;
Pay attention to the responsibilities of planner and executor when collaborating with multiple models;
Do not expose production keys and server credentials directly to Agent;
After automatically modifying the code, you still need to run tests and reviews.

If you plan to use it for a long time, it is recommended to run it in your personal project first, and then gradually connect it to the official warehouse. Especially for Agents that can execute shells, permissions should be given starting from a small age.

Summary

The value of DeepSeek-Reasonix is that it combines the cost-effectiveness of DeepSeek with a terminal programming agent. It is not the most “fool-like” tool, but it is very attractive to people who are willing to adjust configurations, connectors, and long-term terminals.

If your goal is to “use DeepSeek to make a controllable, low-cost, long-session local terminal programming agent”, Reasonix is worth trying. If you only occasionally let AI change a few lines of code, it may be more worry-free to directly use a ready-made IDE plug-in.

Reference sources

esengine/DeepSeek-Reasonix - GitHub

How to use Taste Skill? Add some aesthetic constraints to AI front-end generation

Sat, 06 Jun 2026 22:22:56 +0800

Leonxlnx/taste-skill is a very interesting front-end Agent Skill project. Its goal is not to make another UI component library, but to add a set of “aesthetic constraints” to AI programming tools such as Codex, Cursor, and Claude Code to reduce the template interface that looks AI-like at first glance.

The project README calls it Anti-Slop Frontend Framework. This statement is a bit exaggerated, but the direction is very accurate: the biggest problem when writing front-ends for AI is often not the inability to write code, but that the default layout is too flat, the hierarchy is too weak, spacing seems to be automatically generated, and motion effects and fonts are not judged.

What exactly is it?

Taste Skills are essentially a set of Agent Skills that can be installed, copied, and pasted. They are not runtime dependencies or browser plug-ins, but working rules for AI Agents.

It will require the model to pay more attention when generating the front end:

layout: The layout should not only center the card;
typography: font size, font weight, and line height must be hierarchical;
spacing: white space, margins, and density must match the scene;
motion: Motion effects must serve interaction, not just add animation;
design language: infer design language based on product type;
anti-slop: Avoid templates, placeholders and half-finished output.

The value of this type of skill is not to “write a few more prompts”, but to fix some front-end aesthetic judgments into reusable rules so that they can be used in different projects.

How to install

README recommends using npx skills add to install:

`1`	`npx skills add https://github.com/Leonxlnx/taste-skill`

If you only install the default front-end design skill, you can specify:

`1`	`npx skills add https://github.com/Leonxlnx/taste-skill --skill "design-taste-frontend"`

If you rely on legacy behavior, you can also install v1:

`1`	`npx skills add https://github.com/Leonxlnx/taste-skill --skill "design-taste-frontend-v1"`

The project also states that you can copy any SKILL.md directly into the project, or paste the content into the ChatGPT / Codex conversation for use. In other words, it does not have to be bound to a specific platform.

What Skills are built in?

Taste Skill is not just one file. There are various skills listed in the README:

Skill	Install name	Purpose
taste-skill	`design-taste-frontend`	Default front-end aesthetic rules, currently v2 is still in experimental iteration
taste-skill-v1	`design-taste-frontend-v1`	Preserve legacy behavior
gpt-tasteskill	`gpt-taste`	Strict version more suitable for GPT / Codex
image-to-code-skill	`image-to-code`	First generate the reference image, then analyze, and then write the code
redesign-skill	`redesign-existing-projects`	Audit existing projects first, then change the UI
soft-skill	`high-end-visual-design`	High-end, soft, and plenty of white space visual direction
minimalist-skill	`minimalist-ui`	Notion/Linear style restrained product UI
brutalist-skill	`industrial-brutalist-ui`	Industrial, Swiss font, experimental style with strong contrast
output-skill	`full-output-enforcement`	Used to suppress half output and placeholders

There are also image generation skills for generating web, mobile and brand board reference images. They do not directly output code, but produce visual references, which are then handed over to Codex, Cursor or Claude Code for implementation.

Suitable for how to use

If you just ask AI to write a background form, simply stating the requirements may be enough. But if you want to do:

Product official website;
SaaS Dashboard;
Mobile page;
Brand landing page;
Portfolio;
High-end tool interface;
Existing project UI redesign;
Restore frontend from reference image.

Then Taste Skill will be more useful. It helps you constrain “what kind of interface this should be” in advance, instead of waiting for the AI to generate a bunch of cards and then scolding it back bit by bit.

I would use it like this:

New projects use design-taste-frontend first;
Codex/GPT projects can try gpt-taste;
Use redesign-existing-projects for revision of existing projects;
Add minimalist-ui, high-end-visual-design or industrial-brutalist-ui when there is a clear style;
If the AI always leaves TODO or omits code, add full-output-enforcement.

It is not a universal aesthetic button

Taste Skill solves the problem of “AI front-end output is too templated”, but it is not a designer replacement.

A few boundaries should be made clear:

It cannot define your brand positioning for you;
It cannot guarantee that every generation will look good;
It is more suitable for people with a foundation of front-end aesthetics to make secondary judgments;
No matter how detailed the skill is, you still need to provide product background, audience and functional priorities;
Teams with existing design systems should not let skills cover internal specifications.

In other words, it is more like a “front-end generated aesthetic scaffolding”. It can raise the default lower limit, but the final effect still depends on you reviewing, taking screenshots, adjusting CSS, and checking real devices.

Summary

The value of taste-skill is that it turns a lot of front-end design experience into Agent-executable rules. For tools such as Codex, Cursor, and Claude Code, this skill is very suitable to make up for the shortcomings of “being able to write code but easily losing quality”.

If you often use AI to generate front-end pages, especially if you are fed up with big gradients, big rounded corners, full-screen cards, random icons, and layerless template-like interfaces, you can use it as a starting point. But don’t think of it as a design director, real projects still require you to make your own choices.

Reference sources

Leonxlnx/taste-skill - GitHub