Start the third week of February with battle-tested prompting strategies for Claude, ChatGPT, GPT-5, and Codex, from fixing your AI's yes-man problem to surviving the dreaded "dumb zone" mid-conversation.
February's off to a wild start. New models dropping, agent teams burning through tokens like it's Black Friday, and everyone's suddenly arguing about whether Claude or Codex is the better coding partner (spoiler: it depends on whether you value speed or thoroughness).
This month's Prompt Tips of the Day collection tackles the stuff that actually moves the needle: how to stop your AI from agreeing with everything you say, a dead-simple trick for knowing when your conversation has gone stale, and a framework for treating AI like an employee instead of a search bar.
Inside: anti-sycophancy settings you can copy-paste in 30 seconds, the "canary in the context window" hack, agent team workflows that'll make your wallet weep, and a philosophical guide to graduating from chatbot user to AI-native operator.
Bookmark this page. Future You (buried in tabs and half-finished agent builds) will thank you.
Recently, somebody asked why we’re so focused on Anthropic/Claude in the Prompt Tip of the Day lately. It’s a good question!
Frankly, it's because no one else is innovating as much as Anthropic for general AI use-cases right now, and you’re probably behind if you're not learning how to use Anthropic’s tools (maybe Perplexity Cloud changes that; still TBD).
I know that sounds dramatic, but neither Google or OpenAI are making as easy to use, practically useful, truly agentic tools for normies (like us). Where is OpenAI’s answer to Cowork, their supposed Google Workspace competitor? We heard a rumor it could be coming in the next few weeks… but they’re sleeping on it.
It feels increasingly like the trick to working with AI is reducing the total number of prompts you need to make in the first place, through actual automation.
Things like plugins, and skills, and now scheduled automations build those automations into the system for you. Worry less about prompting, and more about building systems.
So yeah, today’s prompt tip is this: time to learn how to effectively use skills!
Two resources will help you do this:
Stop re-explaining yourself to ChatGPT and Claude every single conversation. Anthropic just published a full guide to building "Skills" for Claude, and it's a game-changer for anyone with repeatable workflows.
Here's the idea: a Skill is basically a tiny instruction manual (stored as a simple folder) that teaches Claude how to handle specific tasks YOUR way. Write reports in a certain format? Always follow a 5-step research process? Have a brand voice guide? You teach Claude once, and it applies those instructions automatically every time the topic comes up.
The coolest part: you don't need to code anything. A Skill is just a markdown file with two things:
Upload it to Claude via Settings > Capabilities > Skills, and you're done.
Our favorite insight: Anthropic recommends starting by nailing ONE task perfectly in a conversation, then packaging that winning approach into a Skill. Don't try to build a Swiss Army knife on day one.
Yesterday, somebody asked why we’re so focused on Anthropic in the Prompt Tip of the Day lately. Frankly, it's because no one else is innovating as much as Anthropic for general AI use-cases right now, and you’re probably behind if you're not learning how to use Anthropic’s tools (maybe Perplexity Cloud changes that; still TBD).
I know that sounds dramatic, but neither Google or OpenAI are making as easy to use, practically useful, truly agentic tools for normies (like us). Why? See above.
It feels increasingly like the trick to working with AI is reducing the total number of prompts you need to make in the first place, through actual automation. Things like plugins, and skills, and now scheduled automations build those automations into the system for you. It's less about prompting, and more about building systems.
Take today’s launch: You can now tell Claude to do something once and have it run automatically—every day, every week, whenever. Scheduled Tasks in Cowork lets you type /schedule, describe a task (e.g. "summarize yesterday's Slack messages"), pick a cadence, and Claude handles it on autopilot with full access to your Google Drive, Slack, and plugins. Watch the walkthrough.
Meanwhile, for engineers, Claude Code Remote Control lets you run claude remote-control in your terminal, then continue your session from your phone, tablet, or any browser. Claude keeps running locally, and you can steer it from anywhere. (check Simon Willison's early impressions here, and Nate Herk shows how)
There’s one catch w/ scheduled tasks: they need your computer awake + Claude Desktop open. Also, Remote Control needs Pro or Max. Download Claude here.
Anthropic just launched a plugin marketplace for Cowork (full demo here), with pre-built agents for finance, HR, engineering, design, and more. But the real unlock for builders? Claude Code now has its own plugin ecosystem with 9,000+ community-built extensions you can install in seconds.
Here's how to get started:
/plugin in Claude Code to open the marketplace. You'll see curated plugins from Anthropic and the community. Install one with /plugin install [name]@[marketplace]. Done. No config files, no setup.claude-plugins-official) comes pre-loaded. Want more? Run /plugin marketplace add owner/repo with any GitHub repo that hosts a marketplace file..claude-plugin/plugin.json manifest with a name and description, then drop a skills/ folder with a SKILL.md file inside. Test locally with claude --plugin-dir ./my-plugin. When it works, push to GitHub and share with /plugin marketplace add.The bottom line: plugins turn Claude Code from a coding assistant into a customizable dev environment. /plugin is the new npm install for your AI workflow.
Anthropic just published their AI Fluency Index, studying how ~10K people actually use Claude. The biggest finding: people who iterate get 2x more value. Users who treated AI's first response as a starting point showed double the rate of productive behaviors like questioning reasoning and identifying gaps.
The catch: when AI produces polished outputs (code, documents, apps), users get less critical. They're 5.2 percentage points (pp) less likely to spot missing context and 3.1pp less likely to question reasoning. The shinier it looks, the less we inspect it.
Two tips:
"What's the single smartest and most radically innovative addition you could make to this project at this point?"
Try it with a few different models. You'll be surprised.
Bottom line: The best AI users don't write the fanciest prompts. They don't stop at the first answer.
Here's a trick borrowed from how Grok 4.20 actually works, and you can use it with any AI right now.
Make the AI debate itself.
Instead of asking one question and accepting the answer, try this prompt structure:
"Give me three different perspectives on [your question]. For each perspective, explain what evidence supports it and what evidence contradicts it. Then tell me which perspective has the strongest support and why."
This forces the model to do internally what Grok's four agents do externally: explore multiple angles, weigh conflicting evidence, and synthesize a stronger conclusion. It's especially powerful for decisions where you're stuck between options.
Bonus: If the answer matters, follow up with: "Now argue against your own conclusion. What did you miss?" You'll be surprised how often the AI finds real holes in its own reasoning.
Stanford AI computer scientist Harper Carroll has a great prompt tip for you today:
If you’re using a non-reasoning AI model (so the faster / free ones), you should put your task (the question you want the AI to answer) BEFORE the context (any text or descriptions or other relevant content) in your prompt.
This causes the AI to read the context you give it with the task to be done front and center.
She says this advice actually works for human comprehension, too: during the reading comprehension portion of her SATs, she was told to read the question to answer before reading the essay, and it worked (she got into Stanford, after all).
There’s some free SAT advice for any parents out there!
Here's a dead-simple trick that quietly improves your AI’s performance across Gemini, GPT, Claude, and Deepseek, with zero extra latency and zero extra output tokens (i.e. the words / code generated): just repeat your prompt twice.
Researchers at Google found that simply sending your query twice in a row (back-to-back, no separator needed) wins on 47 out of 70 benchmark tests, with 0 losses.
Since large language models (the AI models behind ChatGPT, Gemini and Claude, abbreviated to LLMs) process tokens left-to-right, early tokens can't “see” what comes later. Repeating the prompt lets every part of your query attend to every other part — essentially giving the model a second pass at understanding your full request before it ever generates a response.
Here's how to use it, ranked from easiest to most powerful:
Our favorite insight: the gains are most dramatic when your question and context are in an awkward order — like when the answer choices come before the question. In one test, Gemini 2.0 Flash-Lite's accuracy on a name-retrieval task jumped from 21% to 97% just from repeating the prompt. Wild.
One caveat: this works best when reasoning is off. If you're using chain-of-thought or "think step by step," (which “extended reasoning” or “thinking” does automatically) the model already kind of re-reads the prompt on its own; so the gains are smaller (though still neutral-to-positive!).
Try it on your next long, context-heavy prompt and see what happens!
Everyone building AI agents eventually hits the same wall. Developer akira nailed it in a viral thread: you make an agent, it sucks on benchmarks, you add complexity (swarms, task managers, meta-agents), each fix creates a new problem, and eventually you circle back to where you started. The punchline? "It's all just context engineering."
But if that's true — if agent performance mostly comes down to managing what the model sees and when — then the question becomes: which techniques actually matter?
Minh Nhat Nguyen published a ranked tierlist of agent abstractions for Claude that answers this surprisingly clearly. Here are the big takeaways:
The simplest techniques deliver ~80% of the value. The top four ranked items — subagents, metaprompting, asking the user more questions upfront, and thinking prompts — are all what Minh calls "direct buffs." They improve outcomes with minimal setup and almost no downside. You can implement any of them in minutes.
Subagents are #1 because they solve the core problem: context rot. As conversations get longer, agent performance degrades because the model is swimming in irrelevant context. Subagents isolate tasks into clean, focused windows. And as models get smarter, they get better at knowing when to spawn them — meaning this technique scales with capability rather than fighting it.
Metaprompting is the most underrated trick on the list. The idea: before running a task, use AI to expand your short request into a full prompt file with a scratchpad. Minh says he spends 3 minutes prompting a 20-minute task — and gets dramatically better results because the model starts with clearer instructions and built-in sanity checks. You're using AI to write better prompts for AI. Very meta, but very effective.
Long-running agents require taste, not just tooling. You need to understand the "shape" of a task — whether it's better as one 1-hour run or four 15-minute runs — and that intuition only comes from experience at shorter durations first. There's no shortcut here. Start small, build up.
Multi-agent setups are mostly not worth it yet. Parallel and role-based multi-agent architectures have high skill floors with uncertain payoff. The coordination overhead (prompting, merging, debugging) usually eats whatever time you saved. And hard-coded role specialization — like "planner + executor" — ages poorly because models evolve so fast that the heuristics you bake in become obsolete within months.
The meta-lesson from both posts is the same: scale complexity with your experience, not your ambition. Start with subagents and metaprompting. Get comfortable with longer tasks. Only then consider multi-agent architectures. Most people jump to the complex stuff too early and wonder why nothing works.
The key takeaway: the agent builders who ship the most aren't the ones with the fanciest architectures — they're the ones who mastered the boring basics and resisted the urge to over-engineer.
Most AI coding failures don't happen because the model wrote bad code—they happen because you built on a wrong assumption. This episode of the AI That Works podcast breaks down two techniques that the best AI engineers use to prevent exactly that: learning tests and back pressure.
Learning tests (12:22) are small throwaway scripts you write before building anything—not to ship, but to prove how an external system actually works. Think of it like curling an API before you build on it, but formalized. The concept comes from Michael Feathers' Working Effectively with Legacy Code: when a system is hard to understand, just poke it from the outside and document what happens.
The hosts' workflow: read docs → read external resources → write learning tests → then implement. No coding until assumptions are verified. They even have Claude Code generate learning tests automatically by pointing it at docs and existing test examples.
Why? Because without them, a wrong assumption baked into your research leaks into your plan, leaks into your implementation, and then three phases deep you realize you have to throw everything out.
Back pressure (46:29) is the other half: giving AI models deterministic feedback loops—type checkers, compilers, unit tests—so they can catch their own mistakes without you reviewing every line.
The key insight, and maybe the best one-liner on AI coding we've heard:
"You can accidentally steer a model. You cannot accidentally steer a type checker."
When you ask a model "is this code good?"—it'll say yes. Ask "what's wrong with this code?"—it'll find 10 problems. Same model, same code, different answer. That's why you want deterministic tools (compilers, linters, test suites) giving the feedback, not another LLM.
Here's how to actually apply this:
The hosts say the best AI engineers they know spend 3 days designing the back pressure system—not writing a single line of code. They enumerate the test cases in plain text, feed that to Opus, run it in a loop for two days, and get back 20,000 lines of working code. Because they designed the feedback loop, they didn't have to babysit the model.
One more practical takeaway on knowing when to plan vs. vibe: instead of incrementally inching toward the "right" amount of planning, try "making the other mistake." Over-plan one task, skip all planning on the next. You'll binary search your way to good instincts way faster than playing it safe every time.
Our favorite insight: Stop thinking about writing better prompts for your coding agent—start thinking about what deterministic checks your agent can run on itself. The more layers of automated feedback you give it (type checker → compiler → unit tests → visual architecture checks), the less you have to be in the loop. That's the real leverage
Anthropic just published updated prompting best practices for its latest Claude models—and the TL;DR is that many of the prompting habits we've all built up over the past two years are now actively backfiring.
Anthropic engineer Charmaine Klee put it bluntly: she saw "huge leaps in intelligence" the moment she started removing old prompts. "A lot of our bandaid fix prompts are now getting in the way of outcomes."
Here's everything you need to know:
1. Stop micromanaging the model's thinking
Three specific things to cut:
As one commenter put it: over-prompting feels like "standing over someone's shoulder saying 'make sure you breathe, don't forget to blink.'" The instruction adds noise, not signal.
2. Be specific about WHAT, not HOW
Instead of telling the model how to think, Anthropic recommends being ultra-specific about what you actually want. Two techniques:
3. Tell it what to do, not what NOT to do
This one's subtle but powerful. When controlling output format:
Anthropic also suggests wrapping instructions in XML tags (e.g.
4. Say "do it" not "suggest it"
The new models take instructions literally. If you say "Can you suggest some changes to improve this function?"—Claude will suggest changes. If you want it to actually make the changes, say "Change this function to improve its performance." This applies to ChatGPT too: vague asks get vague outputs. Direct asks get action.
5. Use effort as your main control lever
Instead of prompt-engineering the model into working harder or softer, Anthropic says to adjust the effort setting (available in Claude's API, and likely coming to more interfaces). Think of it like a volume knob:
This replaces the old approach of writing longer, more aggressive prompts to get better results.
6. Watch for overengineering
The new models can be too proactive—adding features you didn't ask for, overbuilding solutions, creating unnecessary files. If you're getting more than you bargained for, Anthropic suggests adding: "Only make changes that are directly requested or clearly necessary. Keep solutions simple and focused."
7. For long or complex tasks: structure your state
If you're working on multi-step projects across several conversations, Anthropic recommends asking the model to track its own progress in a structured format—like having it maintain a to-do list, write tests before starting work, or create setup scripts. This helps it pick up where it left off without losing context. Git works especially well for this if you're working on code.
8. For research tasks: give success criteria and let it run
The new models are strong at agentic research—searching multiple sources, building competing hypotheses, and self-critiquing findings. But they need a clear definition of "done." Tell Claude what a successful answer looks like, ask it to verify across multiple sources, and let it go.
Our favorite insight: Charmaine Klee's core point applies beyond Claude: the best prompts for 2025-era AI models aren't longer or cleverer—they're cleaner. Strip out the workarounds you built for dumber models, be precise about what you want, and trust the model to figure out the how. As another commenter put it: "Clear constraints plus success criteria beats 'think harder'"—every time.
If you've ever wanted an AI to just fix your code but didn't want to open a terminal to do it, Claude Code Desktop is worth your attention.
It's a visual app (available on Mac and Windows) with three tabs that do very different things: Chat works like normal Claude. Code gives Claude direct access to your local files, shows you exactly what it wants to change, and lets you approve or reject each edit. Cowork runs an autonomous agent in the background while you go live your life. Like a sous chef who preps everything while you're still picking the recipe.
Here's the real workflow tip, straight from Anthropic's best practices: start every big task in Plan mode. Claude will map out the full approach without touching a single file. Review the plan, tweak it, then switch to Code or Ask mode to execute. It's the difference between "just start cutting" and "let's look at the blueprint first."
A few things that make this genuinely useful:
You don't need to write code to use it. Point Claude at a project folder and type things like "find all TODO comments and fix them" or "add tests for the main function." It figures out the rest.
Pro tip: if you're already a CLI user, both run the same engine and share all config. You can even move a terminal session into Desktop by typing /desktop.
Next up: You heard about Anthropic's Cowork Legal plugin tanking Thomson Reuters stock 16% and LexisNexis parent RELX 14%. Here's how to actually use it (and 10 other new plugins you might've missed).
The Legal plugin in 60 seconds: Open Claude Desktop → Cowork tab → Plugins → find "Legal" → click Install. It's free with any paid Claude plan ($20/mo and up). Once installed, you get 7 slash commands:
/review-contract – Uploads a contract and flags every clause GREEN (good), YELLOW (review), or RED (danger) against your org's playbook, with specific redline suggestions./triage-nda – Rapid-sorts incoming NDAs into "approve as-is," "counsel review," or "full review."/compliance-check – Runs your agreements against GDPR, CCPA, HIPAA requirements and flags gaps./risk-assessment – Generates a high / medium / low risk matrix for any document./vendor-check – Pulls up vendor agreement status, expiration dates, and auto-renewal traps./brief – Creates daily legal summaries, topic research, or incident response briefings./respond – Drafts templated replies for data subject requests, discovery holds, etc.The real power move? Create a playbook.md file with your org's standard positions (what's acceptable, what's a red line) and upload it to the plugin's skills folder. Now every review is calibrated to your rules, not generic ones.
But Legal is just one of 11 Cowork plugins Anthropic dropped. The others: Sales (prospecting, outreach, deal strategy), Productivity (task management, daily planning), Product Management (specs, roadmaps, user research), Marketing (content, campaigns, analytics), Finance (journal entries, reconciliation, variance analysis), Data (SQL, dashboards, visualizations), Customer Support (ticket triage, knowledge bases), Enterprise Search (one search across email, chat, docs, wikis), and Bio Research (preclinical research tools). All free, all one-click install.
Our favorite insight: The plugin doesn't just keyword-scan contracts. It reads the whole document first because clauses interact with each other (e.g. an uncapped indemnity might be offset by a limitation of liability elsewhere). That context-awareness is what separates this from Ctrl+F on steroids.
We went down a Reddit rabbit hole this week and came back with gold. Five posts, 60+ tips, thousands of upvotes, one goal: making you dramatically better at working with AI. We consolidated every unique tip, cut the fluff, and organized it all into one mega-guide.
A viral post on r/PromptEngineering broke down a five-layer framework that turns vague prompts into professional-grade output. The structure: ROLE → CONTEXT → TASK → FORMAT → CONSTRAINTS.
Here's the quick breakdown:
Top-voted commenter Romanizer shared a smart workflow twist: drop your rough idea into the LLM and ask it to build a prompt using this framework. Then use that polished prompt for the real task. Let the AI write the prompt that makes the AI better. Very meta... but very useful.
Another commenter Ijere noted that order matters: ROLE → TASK → CONSTRAINTS → CONTEXT → FORMAT can sometimes be more reliable, since models tend to weight instructions near the top more heavily.
Developer ykdojo published 45 Claude Code tips after 11 months of intense daily use (4,100+ sessions, 17.6M tokens consumed). His GitHub repo has 2.9k stars. Here are the essentials:
Talk to it with your voice. Use a local voice transcription app like superwhisper, MacWhisper, or the open-source Super Voice Assistant. Even with transcription mistakes, Claude is smart enough to interpret what you mean. ykdojo writes entire blog posts this way, even on planes, whispering into Apple EarPods. In a room with others? Whisper into earbuds. People talk to coworkers all day anyway; you're just talking to a slightly smarter one.
Break down big problems into small ones. Instead of going from A to B directly, go A → A1 → A2 → A3 → B. When building a voice transcription app, ykdojo first built a standalone model downloader, then a standalone voice recorder, then a standalone transcriber, then combined them. This is classic software engineering, and it works just as well with AI.
Learn the essential slash commands. Type / to see them all, but the must-knows are:
/usage to check your rate limits/stats for a GitHub-style activity graph of your usage/clear to start fresh/compact to summarize and free up context spaceSet up terminal aliases. If you use Claude Code daily, set shortcuts in your shell config (~/.zshrc or ~/.bashrc): c for Claude, ch for Claude with Chrome, co for VS Code. Combine with flags: c -c continues your last conversation, c -r shows recent ones to resume.
Cmd+A is your best friend. When Claude Code can't fetch a URL directly, just select all (Cmd+A / Ctrl+A), copy, and paste the page content straight in. Works for terminal output too. For Gmail threads, hit "Print All" first to expand everything, then select all from the print preview.
One commenter (champdebloom) added another great option: use the Obsidian Web Clipper Chrome extension to copy any web page as clean Markdown. It strips out all the formatting junk and gives you structured content that AI tools can actually work with. Even if you don't use Obsidian, the clipper is a handy way to capture web content.
This is where intermediate users become power users. AI context degrades over long conversations, like milk going stale. Commenter Spiritual_Bunch334 confirmed this: Claude performs noticeably better in the first 10-15 exchanges versus later in a long session.
Start fresh often. New conversation for every new topic. If output quality dips, that's your signal.
Write handoff docs instead of auto-compacting. Before starting fresh, ask Claude to create a HANDOFF.md file summarizing what's been tried, what worked, what didn't, and what's next. Then open a new conversation and just point it to that file. The fresh agent gets full context without the baggage. ykdojo even built a /handoff slash command to automate this.
Use path-specific rules instead of one massive CLAUDE.md. From IulianHI's power tips post: create a .claude/rules/ folder with modular rule files that only apply to specific file paths. Your API rules load only when working on API files; your frontend rules load only for components. Context stays clean. Commenter deadcoder0904 elaborated: in monorepos where one project uses Biome and another uses oxlint, this prevents wasted tokens on irrelevant formatting rules.
Use CLAUDE.md imports for shared team knowledge. Instead of duplicating instructions across repos, use @ imports: @docs/architecture.md for system design, @~/.claude/company-standards.md for team-wide standards. Imports are recursive up to 5 levels deep.
Slim down the system prompt. Claude Code's system prompt and tool definitions eat ~19k tokens (~10% of your 200k context) before you even start. ykdojo's patch system cuts that to ~9k tokens, saving ~50%. Also: enable lazy-loading for MCP tools so they only load when needed, by adding "ENABLE_TOOL_SEARCH": "true" to your settings.
Keep CLAUDE.md simple and review it periodically. Start with nothing. Only add instructions when you catch yourself repeating the same thing. And review it regularly because old instructions get stale.
A developer who's shipped 30+ apps with paying customers shared five rules that prevent the "four hours of debugging" spiral. Commenter martiantheory, an 18-year software engineer, vouched for most of these.
Self-updating rules files. Have Claude update its own .cursorrules or CLAUDE.md as you build. Every time you solve a tricky bug or establish a pattern, make it document the fix in real time. After a few days, your rules file becomes a living document that prevents the same mistakes twice. One important caveat from commenter moxyte: don't let AI rewrite its own ruleset unsupervised. Have it suggest updates that you approve.
MCPs for context, not convenience. Set up MCP servers for GitHub, your file system, databases, and APIs. When Claude can actually read your existing code and reference real documentation instead of hallucinating, you eliminate a huge chunk of bugs before they start. But commenter ninjaeon warned: only enable the minimum MCPs you need, since they eat context. The OP recommended focusing on software-specific MCPs like Figma, Stripe, Vercel, and Supabase for the biggest ongoing value.
Checkpoint before every "quick fix." The moment you think "this should be easy," stop and git commit. Endless debugging loops almost always start from a "small change" that cascades into chaos. When you have clean checkpoints, you roll back to working code instead of playing archaeologist with your own project.
Force explicit reasoning before code. Prompt Claude with "before writing any code, explain your approach and identify what could break." Both Cursor and Claude Code have thinking / planning modes for this. Without it, you get confident-sounding code that quietly breaks three other things.
Scope lock aggressively. Always specify: "Only modify [specific file]. Do not touch anything else unless you ask first." Without this, Claude will "helpfully" refactor a dozen files to fix one bug. Scope creep is the silent killer of vibe coding.
These are for the power users who want to squeeze every drop of productivity out of Claude Code.
Hook into everything. Claude Code has a hook system that intercepts every tool call. Want auto-linting after every file edit? Security checks before every bash command? Add hooks to .claude/settings.json. Exit code 2 blocks the action entirely. Commenter pbalIII shared a great pattern: a PreToolUse hook on Bash that checks against a blocklist of destructive operations (rm -rf, DROP TABLE) and blocks them before Claude can execute.
Route tasks to cheaper models with subagents. Not every task needs Opus. Create subagents that use Haiku for read-only exploration tasks (searching, grepping, globbing) at a fraction of the cost. Reserve Opus for implementation. pbalIII noted you can batch 10 parallel Haiku searches and merge results instead of one expensive Opus pass.
Inject live data with !command syntax. Skills can run shell commands as preprocessing before sending the prompt to Claude. Use !backtick syntax to inject the actual output of git diff --stat or gh pr view directly into the prompt.
Run skills in isolated contexts. Add context: fork to a skill to run it in a completely isolated subagent. The skill runs in its own context window and returns a summary. Your main conversation stays clean.
Use containers for risky long-running tasks. Run Claude Code with --dangerously-skip-permissions inside Docker containers instead of your main system. If something goes wrong, it's sandboxed. You can even have your local Claude Code orchestrate a "worker" Claude Code in a container via tmux.
Git worktrees for parallel branch work. Working on multiple features simultaneously? Git worktrees let you work on different branches in different directories without conflicts. Just ask Claude Code to set them up.
Manual exponential backoff for monitoring. Waiting on a Docker build or CI job? Ask Claude to check status with increasing sleep intervals (1 min, 2 min, 4 min...). More token-efficient than gh run watch, which outputs continuously.
Resume sessions from PRs. Use claude --from-pr 123 to pick up exactly where a PR left off, with full context. Great for async workflows where a teammate opens a PR and you continue the work.
Audit your approved commands. After someone's Claude Code ran rm -rf and wiped their home directory, ykdojo built cc-safe, a CLI that scans your settings for risky approved commands. Run npx cc-safe . periodically.
Obsidian Web Clipper: Free Chrome extension that saves any web page as clean Markdown. Even if you don't use Obsidian, it's great for grabbing web content to feed into AI tools. 300K+ users, 4.8-star rating.
Gemini CLI as a fallback. Claude Code can't fetch certain sites (like Reddit). Create a skill that uses Gemini CLI to fetch blocked content through tmux. Slow but surprisingly effective for research.
Notion as a format converter. Want to preserve hyperlinks when pasting into Claude Code? Paste into Notion first, then copy from Notion as Markdown. Works in reverse too: paste Markdown into Notion to convert it for platforms that don't accept raw Markdown.
Clone and half-clone conversations. Want to try a different approach without losing your thread? /fork clones the current session. The half-clone script keeps only the recent half, reducing token usage while preserving your latest work.
So, a Reddit user took blocky Half-Life 1 and 2 screenshots and converted them into near-photorealistic images using Flux.2 Klein 4B, a tiny open-source image model you can run locally.
The prompt? Just six words: "Change the scene to real life." That's it. Default settings, 4 steps, done. The results aren't perfect, but they're shockingly good for a model small enough to run on consumer hardware.
The real gem came from commenter richcz3, who discovered that adding "preserve lighting, preserve background, fix hands, fix fingers" to the end of the prompt dramatically improved the output. Without it, Klein tends to blast everything with sunshine (City 17 looked like a theme park). With it, the original mood, atmosphere, and composition stay intact while only the realism gets upgraded.
In our opinion, this is a preview of where gaming is headed. Multiple commenters pointed out that once this kind of processing hits real-time speeds, you'll be able to replay any classic game with a photorealistic AI filter. We're not there yet on frame rate, but the image quality is already wild.
Gemini's image generation can be impressive—but this viral Reddit thread is a masterclass in what happens when it isn't. A user asked Gemini to put his face on a cowboy poster. The result? A cut-and-paste job your 12-year-old nephew could've done in MS Paint.
But the comments are where the real gold is. Here's what the community figured out about getting Gemini image gen to actually cooperate:
Gemini is a one-shot tool for images. Nail the first prompt or start fresh—editing is where dreams go to die.
Got Word docs that should be spreadsheets? Or PDFs full of data trapped behind terrible formatting? Claude can now create and edit Excel, Word, and PDF files right inside the chat. But the real trick isn't the tool; it's how you prompt it.
It's called schema-first prompting: instead of saying "extract the data from this PDF," you define exactly what the output should look like before Claude touches the document. Think of it like handing someone a blank spreadsheet with the headers already filled in, then saying "now fill this in."
For converting a Word doc into a usable Excel sheet, upload your .docx and try:
"Convert this Word document into an Excel spreadsheet. Use these column headers: [Name, Date, Amount, Status, Notes]. Each row = one entry. Include a formula to sum the Amount column and flag any Status marked 'overdue' in red."
For extracting info from messy PDFs:
"Extract all [invoices / client records / form entries] from this PDF. Return the data in a table with these exact columns: [Field 1, Field 2, Field 3]. If a field is missing or unreadable, write 'N/A' instead of guessing."
God of Prompt revealed 10 advanced prompting techniques used by researchers for structured, verified, and expert-level outputs.
These aren't your typical "act as a..." tips. We're talking about methods like structured chain-of-thought, self-verification loops, and constrained output formatting that researchers actually use to get consistent, high-quality results from frontier models.
He shared the full breakdown in a thread on X, but if you don't want to scroll through the timeline, here's a shortcut: copy the image from his post, paste it into your AI, and ask it to "transcribe this image exactly as it appears." Then save the output as a reference doc or a skill.
Sometimes the best prompt tip is "let AI read the prompt tips for you."
Your AI is a yes-man. Here's how to fix it in 30 seconds.
Go to Settings → User Preferences (Claude) or Custom Instructions (ChatGPT) and add:
- Be anti-sycophantic - don't fold arguments just because I push back
- Stop excessive validation - challenge my reasoning instead
- Avoid flattery that feels like unnecessary praise- Don't anthropomorphize yourself
The difference is night and day.
Before: User tells Claude he impulsively bought six concert tickets to Switzerland. Claude says "That's an interesting approach!"
After: "Spending $600-1,800 on tickets as a forcing function to 'be more social' is an expensive, backwards way to build connections."
Our favorite insight: For code reviews, skip "review this code" and try "find problems in this code, assume there are at least 3." Forcing AI to hunt for issues instead of validating your approach completely changes the output (and catches the flaws you'd otherwise ship to production).
P.S: This longer version from the top comment is worth saving too.
Want pro-level slides without the hassle? This clever Kimi prompt hack turns simple text descriptions into full McKinsey-style presentations, complete with charts, matrices, and a clean tech-minimalist vibe in royal blue and grey.
Feed it an analysis topic like GenAI videos, and watch it build dense, high-impact decks with serif fonts for titles and perfectly formatted data viz.
How it works: describe your presentation topic in plain language, add "McKinsey-style" to your prompt, and Kimi handles the layout, color scheme, and data visualization formatting automatically.
Our favorite insight: Use "McKinsey-style" in your prompt for instant pro formatting. No design skills needed, no MBA required. Describe and deploy.
Did you know there's a Claude in Excel add-in (beta for Pro+ users)? It's basically Claude inside your spreadsheet. And lucky for us, Anthropic recently published a 7-min tutorial on how to use it.
Here's what they say:
First, install it here.
Open with Control+Option+C (Mac) or Control+Alt+C (Windows).
Claude shows cell-level citations for everything it references. You click the citation boxes to jump directly to the cells it used; perfect for verifying its work.
Ever notice ChatGPT or Claude getting... dumber halfway through a long conversation? Repeating itself, forgetting what you said earlier, giving worse answers?
There's a name for it: the "dumb zone." Once an AI uses roughly half of its context window (its working memory), quality starts tanking. Think of a student with 5 minutes left on an exam and half the questions still blank; it starts guessing instead of thinking.
Here's a trick from Kelvin French-Owen, who helped build OpenAI's Codex: plant a canary at the start of your conversation.
Drop in a random fact early on:
"Quick note for context: my dog's name is Waffle and I had green tea at 7:15 this morning."
When answers start feeling off, ask: "Hey, what's my dog's name?"
If it forgets? Your context is cooked. Start a new chat and paste in just the key details from the old one. You'll immediately get better results.
Pro tip: For important work, keep conversations short and focused. One topic per chat. Your AI will stay sharper, and you'll spend less time cleaning up bad output.
Stop using the wrong AI tool. Productivity expert Jeff Su breaks down when to use which AI tool based on each one's specific superpower:
He also mentions these more niche tools he doesn't use every day: Grok (direct access to the Twitter / X firehose for real-time breaking news), Gamma (presentations), ElevenLabs (voice cloning), Zapier or n8n (automation), and Napkin AI (quick visuals).
Jeff's actual workflow: ChatGPT / Gemini for ideation and research → Claude for final polish → Perplexity to verify facts → NotebookLM to check accuracy.
Our favorite insight: Don't use all five tools just because they exist. Master one tool first (Jeff recommends ChatGPT, but you can start with Claude or Gemini), then add specialists only when you hit a specific problem they solve better.
YouTuber Greg Isenberg and Morgan Linton (CTO of Bold Metrics) gave a masterclass on the philosophical split between Claude Opus 4.6 and GPT-5.3 Codex, and it's not about which is "better."
Here's the breakdown of their live tests:
agent_teams flag in Claude Code settings.json or you're not actually using Opus's agent teams feature.The key insight: Claude asks "should we do this?" while sipping coffee. Codex asks "how fast can I ship?" while already shipping. Spoiler: you'll probably end up using both.
Pro tip: Agent teams are token-hungry. One Opus build burned 150K-250K tokens. Your wallet has been warned, so budget accordingly.
Watch the full breakdown here.
Mitchell Hashimoto (creator of Vagrant, co-founder of HashiCorp) just published the most practical AI adoption guide we've read. His core argument: most people are stuck in the "chatbot phase," using AI like a search engine you talk to. That's like using a smartphone only for phone calls.
The real unlock is agents: AI that can actually do things on your computer (read files, run tasks, check its own work). Here's his framework:
The progression: chat → agents → automations that run on their own. You don't need to be an engineer to follow it.
AI educator Elvis Saravia shared a killer workflow for "agentic image generation" in Claude Code:
The loop = generate → annotate → refine. One prompt, and the agent handles the entire workflow. Check out the DAIR Academy for more content like this; Elvis is awesome!
Boris Cherny (creator of Claude Code) just dropped a thread revealing how the rest of the Claude Code team actually uses their own product.
The top insights:
The takeaway: the Claude Code team uses their tool like five developers working in parallel. This is what we've been saying, y'all. Multi. Agent. Swarms.
We put together a quick "too long, didn't scroll" summary of the thread here if you're interested.
Claude Code just launched a plugin system that lets you create custom skills, agents, and hooks to extend its capabilities, and it's surprisingly simple to build your own.
Here's the quick version: create a folder with a .claude-plugin/plugin.json manifest file, add a skills/ directory with markdown files, and you've got a shareable plugin. For example, a code review plugin is just a folder structure with instructions in SKILL.md.
The coolest part? You can convert your existing .claude/ configurations into plugins with just a few copy commands. Start with standalone configs for personal use (/hello), then package them as plugins when you want to share with your team (/my-plugin:hello).
Our favorite insight: Plugins use namespacing to prevent conflicts, so if three teammates all create a /review skill, they won't collide. Each plugin gets its own prefix (like /code-tools:review), making it safe to install multiple plugins without breaking your workflow.
Check out the full Claude Code plugin documentation to start building.
Don't have Claude Code yet? ChatGPT users can do something similar with Connectors (also known as MCP, or Model Context Protocol). Connectors let you integrate external tools and data sources directly into ChatGPT. Instead of building plugins, you connect services like GitHub, Google Drive, or custom APIs to give ChatGPT access to your tools and workflows.
Ali Ibrahim shared Anthropic's advice for agentic prompting in a neatly organized and digestible blog that you all should definitely check out.
And like we said above, there's an official prompting guide for Genie 3, and it's packed with insights that apply way beyond just building interactive game worlds.
Here's their framework in three parts: Environment (your landscape and style), Character (what moves and how), and World Sketch (the preview image that sets everything).
And then there's their universal prompting principles:
Our favorite insight: When your prompt fails, use Gemini to "rewrite, expand, and elaborate" it. Meta-prompting for world-building prompts? Very meta, VERY useful.
Want more tips like this? Check out our Prompt Tip of the Day Digest for January.
Here are all of our previous prompt tip digests for you to catch up fast on the best advice we've found to help you prompt and work with AI.
And if you ever have any specific questions on prompting best practices or where to find additional resources, email us at team@theneurondaily.com to ask us and we'll try to respond directly OR, if broad enough, include that answer in a future Prompt Tip of the Day!
Grant Harvey is the Lead Writer of The Neuron, where he continues to lead the publication's daily coverage of AI news, tools, and trends.
Don't fall behind on AI. Get the AI trends & tools you need to know. Join 700,000+ professionals from top companies like Microsoft, Apple, Salesforce and more.
Property of TechnologyAdvice. © 2026 TechnologyAdvice. All Rights Reserved
Advertiser Disclosure: Some of the products that appear on this site are from companies from which TechnologyAdvice receives compensation. This compensation may impact how and where products appear on this site including, for example, the order in which they appear. TechnologyAdvice does not include all companies or all types of products available in the marketplace.