I've been running an API gateway for DeepSeek for a while now, and I see hundreds of developers' usage patterns every day. One thing keeps coming up: DeepSeek by default is a people-pleaser.

If you say "I think X is the best approach," it'll say "Great point! X is indeed a solid choice." That's fine for brainstorming, but when you're debugging or planning, that behavior is dangerous. It won't tell you you're wrong. It won't poke holes in your plan.

So I started testing ways to break it out of that mode. Here's what actually worked:

1. "Don't flatter me. If my idea is flawed, say so directly. I need honest feedback, not validation."

After this, the tone shifts. It points out edge cases, questions assumptions, pushes back.

2. "Argue against my proposal. What are the three strongest reasons this could fail?"

Forces it into devil's advocate mode. Use before important decisions.

3. "You are a senior code reviewer. Find bugs and design flaws. Be harsh."

Role-setting changes expectations. It stops trying to be nice, starts being useful.

4. "On a scale of 1-10, how confident are you? If below 7, tell me what you're uncertain about."

Flags its own weak spots instead of confidently making things up.

5. The one I haven't seen elsewhere: ask it to argue with itself.

I ask DeepSeek to generate two responses: one supporting my idea, one attacking it. Then I ask it to judge which argument is stronger. The attacking response often surfaces issues the supporting one completely ignores.

These aren't magic prompts. They're just ways to override the default "agreeable assistant" behavior.

I'll be sharing one small tip like this every day — practical stuff to get real work done with AI. If you've got your own tricks, drop them in the comments.

I'm the author of Distill, an open-source coding agent harness (Apache-2.0): https://github.com/samuelfaj/distill

Use case: running DeepSeek as a coding agent without it timing out or burning tokens on every small step.

What I tested: DeepSeek V4.1 Flash at max effort in native Codex (through OpenRouter) against Distill with DeepSeek as the main model and free models from the OpenRouter free router as the worker. Three frozen coding tasks, three runs each, same 300s deadline.

Results:

• Successful runs: 5/9 native vs 9/9 Distill
• Time: 1974s vs 490s
• Cost: at least $0.098 vs $0.012

Chart with the other model pairs: /img/q12ttj8lkwvh1.png

Caveats: native Codex warned about missing model metadata in all nine DeepSeek runs and fell back to default metadata, so this wasn't an officially supported Codex profile. Three native calls timed out without usage receipts, so the native cost is only a lower bound. It's a small benchmark.

BENCHMARKS.md in the repo has the full numbers and the commands to rerun it. Has anyone else run DeepSeek in a planner/worker setup?

Granted a total of $875

Had no idea what this was from until they sent this notice,

Cool they granted back for the past week of usage!

Depois da queda de ontem eu notei que as respostas ficaram um pouquinho melhores, embora ele se perca demais em detalhes e ainda está com inconsistências. Mas vi hoje que tivemos uma nova atualização, podem me dizer o que estão achando? Se alguém já notou algum avanço ou melhora na memória, escrita e desempenho. Boa noite!

I was led to believe there was a door prize for the 10B token club?

Is the free chat function really that bad as people here make it out to be?

I had some problems but most of the time it gives a solid result.

Of course I will need to make some more important work and I was thinking of paying for Claude.

Is it better to use this DeepSeek free chat or is it bad enough to just go straight to a paid subscription?

DeepSeek feels kinda different lately. I’ve noticed that its responses are noticeably slower when I generate random micro-RP scenes and ask it to expand them into longer ones. The slowdown is pretty noticeable, and it makes me wonder if something’s changed behind the scenes. Could this be a sign that DeepSeek V4.1 Pro is on the way? 👀

As claude and gemini has instilled watermarks in their reponses, does DS also has a watermark like that?

if not, do you think it will be implemented tn future?

Insane cache hit.

Does that mean DeepSeek is weak or not so smart in ARC AGI 3? I really hope it will have it as soon as possible, intelligence is FAR more valuable than knowledge

Sorry in advance for my English.

So, I paid for API to roleplay with deepseek as I used to do with website until recent model was launched.

I chose v 4 pro, set temperature to 1,35, filled all necessary info, and I just don't see any difference. Responses are dry, short, lack details. Where are my long beautiful engaging texts?

What else should I do or pay attention to? Any advice, please, from someone who is lucky to enjoy the roleplay.

The consumer interface in https://chat.deepseek.com suffers from:
- Poor instruction following = Not replying in english at times and using bold text in replies even when asked not to
- Hallucinations and making up facts = Assumes things when its not the case
- Poor context management and forgets file details in a long chat = Difficult for studies and verification tasks

Lets send an email to [service@deepseek.com](mailto:service@deepseek.com) requesting for fixes to these. We all enjoy using DeepSeek but the consumer-facing interface could definitely do with some improvements.

Having zero coding skills and not working with this field, I've managed to code a Space Sim with DeepSeek. It's a 100% procedural, browser depedent game with zero dependencies. It features an entire universe generated from a single 300KB HTML file. It's open-source (MIT). Still being developed.

GitHub Repository

Singularvs, as I've called, is a contemplative space simulator inspired by SpaceEngine and the 1984 classic Elite. It features a ~1 Gpc universe with procedural galaxies, hierarchical star systems (up to 8 stars, brown dwarfs, black holes), almost scientifically classified planets, internal tectonic simulations, dynamic skies, and even procedural music.

I didn't write a single line of code by hand. I used natural language to describe what I wanted, the AI wrote, I ran, tested, debugged, answered what happened and so on. By iterating back and forth for 3 days, this is the result. Also, only English and Portuguese as of now. I know both languages and reviewed them too.

• Vanilla JavaScript
• Zero external libraries, zero assets
• Deterministic PRNG
• Xinput controller support (I've only tested my Gamesir Controller)

It's fully open-source and moddable. I do not guarantee it has zero glitches or flaws. But I hope it fits here.

Background

I have been using chat.deepseek.com since February 2026 as an orchestrator: I use it to write and refine the prompts that I then run through the DeepSeek API. This is hobby work - I have no commercial interest.

What changed for me

Around the price change this summer I also noticed the output quality dropping. Since then the gap between the two surfaces has become obvious to me:

• The API is still usable for my work. That is why I keep using it.
• The web chat is no longer usable for me. It produces incorrect work, and in a few cases its instructions damaged a project I was working on instead of advancing it. Hallucinated details make it worse: I can no longer tell a solid answer from a plausible-sounding one without verifying everything myself.

I do not want to overstate this. I have no insight into what changed internally, and I am not claiming that the price change caused it - I am reporting what I observe as a long-time user: the same task, handled fine through the API, is not handled reliably in the web chat.

What I hope for

That DeepSeek restores the web chat to a level where it can be trusted for real work again. It was my entry point into all of this and my prompt workshop.

Question

Has anyone else compared the same task across the API and the web chat recently? Concrete examples (task, expected result, what the web chat produced) would help more than another general complaint.

• A disappointed DeepSeek user, still using the API

Waking up to a few free tokens was awesome... how cool is deepseek.

i searched up deepseek-v4-1-pro and

this thing was shown so idk maybe deepseek v4.1 pro soon

Didn't think I will ever make a complaint about model not behaving as well as two days ago, but something is definitely here

I have noticed that right after the last outage the model became much less consistent, aka more lapses in memory than usual, much more mistakes and rounds spent on correcting its own errors, I even had to point few obvious mistakes in a row, despite it being surprisingly smart right before.

Have they broken something or they decided to dumbify model so 4.1 pro looks better or to save money? Given they are open weight it is really strange to see service inconsistencies like that, and also I don't see how they could save money (aside from people stopping to use them for few days) given the insane per-user efficiency of 4.1 arch

Today, my ds platform API credit hit 0, and im not refilling it, ds4.1 flash has become unusable for technical tasks, as main or sub agent.

I've claude sub, and local gpus, but since 4.0 routed much of my sub tasks to a DS agent, every week it get worst, you need to constantly rewrite more rigid prompts so it does not start testing every single thing in the env, creating new scripts to modify a line in a file(many times wrong) and starting new epic resarch lines when asked to do basic stuff.

As its served today its not usable, so sadly waiting for next model release and hoping for some iq back.

Qwen 3.8 and opus 5.5 are in a totally different league in instruction following, coding and day to day usage, wired that a 27b model on my 24gb 5 year old cards beat it by a wide margin.

Hows ur experience lately?

Since my last post was viral I was very curious about what you guys are making. You dont have to say what ur making if you dont wanna tell its okay

hey guys, just want to know your thoughts about the deepseek search & fetch api. i've been finding ai search engine like exa, tavily and etc. deepseek search api is way cheaper than those existing ai search engine. i haven't tried the api yet. just want to know how was your experince with it (if you have any).

reference:

https://api-docs.deepseek.com/guides/search

I use DeepSeek via DeepClaude in Claude Code. Whenever I switch from Sonnet 5.5 to DeepSeek, I notice that similar challenges take longer. He seems more thorough, and the quality is maybe slightly better, but he used tons of tokens for it. Just tested the samen taks same effort; Sonnet 5.5 took 2.31 minutes, Deepseek took over 12 minutes. Anybody else have similair experiences or can someone explain to me why this could be?

I've been building YoungAi, an open-source project based on a simple idea:

Local AI shouldn't just be about running a quantized model. It should be about building the entire system around it.

YoungAi brings together model inference, aggressive quantization, post-training, agent execution, cloud-connected mobile workflows, sandboxing, and reusable skills.

1. Inference and quantization

YoungAi includes a C99 inference engine with CUDA and Metal backends, targeting local inference for DeepSeek V4.1 Flash.

On my DGX Spark, my current implementation achieves:

• Model size reduced from 510 GB to 113.6 GB using vector quantization.
• 1,055 tokens/s prompt processing on a 12.5K-token prompt.
• 45.5 tokens/s generation on a real agent request with a 14K-token context, using speculative decoding.
• Support for a 1M-token context.

These are results from my own setup, not standardized benchmarks.

2. Post-training and Sidecars

I believe the real value of local AI lies not only in running models, but also in adapting them to specific tasks.

YoungAi provides a post-training workflow using JSONL datasets and supports small, switchable task-specific Sidecars. The goal is to improve domain-specific capabilities without having to replace the entire base model.

3. An agent that does real work

YoungAi can browse the web, read and modify files, execute programs, generate Office documents and videos, use reusable skills, and schedule tasks.

In one real test, a request to find the cheapest DGX Spark online involved 12 reasoning rounds and 43 tool calls over 16 minutes.

The goal is to move beyond chat and enable multi-step workflows that actually produce results.

4. Mobile access and cloud-connected phone workflows

YoungAi also connects local AI workflows to mobile devices. Through remote access, a cloud server and tunnel can connect a phone to the machine running YoungAi, while inference and working files remain on the host.

The mobile interface supports capabilities such as location access, clipboard interaction, file sharing, opening other apps, and task-completion notifications.

This makes it possible to connect locally executed AI tasks with everyday mobile workflows, rather than limiting the assistant to a desktop chat window.

5. Sandboxing and security

Agents need tools, but unrestricted tool access is dangerous.

YoungAi uses OS-level sandboxing, including Landlock and seccomp on Linux and Seatbelt on macOS. Tool calls run in fresh child processes, with workspace restrictions, controlled permissions, and activity logging.

The goal is to enforce security boundaries at the runtime level instead of relying entirely on the model to follow instructions.

This is not a perfect security guarantee, but it provides a foundation for more controlled local agent execution.

6. Skills, memory, and APIs

YoungAi supports reusable Agent Skills, locally stored editable memory, and OpenAI- and Anthropic-compatible API endpoints.

The architecture is designed to make the system extensible without hardcoding every new capability into the core.

Why build the whole stack?

I see five important layers in local AI:

• Inference: Make models run efficiently on local hardware.
• Post-training: Adapt models to real tasks and domain-specific needs.
• Agents: Turn model capabilities into executable workflows.
• Security: Control what agents can do on the host machine.
• Integration: Connect local AI to phones, apps, and external workflows.

Optimizing only one layer leaves much of the potential untapped. A fast model is useful, but it still needs the right skills, execution environment, and task-specific capabilities to become a productive system.

My goal with YoungAi is to bring these layers together into one open-source local AI stack.

Project: https://fodelf.github.io/YoungAi/

Source code: https://github.com/fodelf/YoungAi

Licensed under MIT.

I'm interested in technical feedback from people working on local inference, quantization, post-training, agent runtimes, and sandbox security.

What do you think is the biggest bottleneck in local AI today: model quality, inference efficiency, post-training, or agent execution?