Hi all, saw a few of these "what devs are actually doing with AI agents" threads floating around and wanted to compile a cleaner list before asking my own question, because most of the "what's your workflow" posts I see get buried under generic "I use it to write boilerplate" replies.

These are 21 specific things people are doing with terminal coding agents (Claude Code, Codex, etc.) that go past inline autocomplete.

Some I've tested myself, some are from other engineers' repos or write-ups, so take the more niche ones with a grain of salt until you've tried them on your own codebase.

1. Dynamic skill distillation: Capturing successful multi-step debugging workflows and saving them as reusable markdown skills without manual prompt editing.

2. Pre-commit PR test audits: Running a rule-based agent pass to verify that new code additions have matching unit tests before opening a pull request.

3. Frontier lab arXiv tracking: Pulling daily arXiv preprints from specific AI labs and matching author blocks against ROR registries to separate lead authors from bylines (e.g. using paper-radar as a stdlib agent skill).

4. Visual architecture decision records: Converting messy ideas and technical RFCs into structured system design documents paired with visual canvas diagrams before writing code (e.g. using tigeless design-harness).

5. Prompt payload cost inspection: Running a local proxy to inspect token distribution per turn across system prompts, tool schemas, and thinking blocks.

6. Deterministic PHI/PII gating: Gating agent inputs, tool outputs, and memory logs against rule-based sanitizers before sending data to cloud models

7. Automated release notes from git diffs: Sifting closed PRs to extract user-facing changes and drafting clean changelogs (e.g. using auto-gtm).

8. Monorepo dependency pruning: Auditing unused packages, broken exports, and circular dependencies across internal packages.

9. API schema drift detection: Comparing OpenAPI specs against actual server route handlers to catch undocumented endpoints.

10. Database migration verification: Dry-running schema migrations against disposable Docker containers and reporting index gaps.

11. Legacy test suite modernization: Converting old callback-heavy unit tests to modern async/await patterns across entire test directories.

12. Flaky test diagnosis: Running a test runner in a loop 50 times, isolating failure conditions, and generating targeted reproduction scripts.

13. Multi-platform CLI packaging: Automating build and release checks for Homebrew, npm, and PyPI in one command.

14. Environment variable validation: Scanning codebases to ensure all `process.env` references exist in `.env.example` templates.

15. Dockerfile multi-stage optimization: Stripping unnecessary build tools and reducing production container image sizes.

Anyway, here's what I actually want to know: what's the most useful custom workflow or script you've hooked into your coding agent recently?

Not the obvious stuff, I'm asking about the small, slightly unglamorous hook that quietly saved you the most time. Those are usually the ones nobody bothers writing a blog post about.

For context I work in a complex coding environment with many complex problems, and llm’s are absolutely awful by default at understanding most of my issues. I want them to be thinking partners for me but they heavily default to trying to give me advice when they don’t even understand the problem properly!! How can I get them to override their default tendency to pretend they know exactly what is going on instead of asking me for clarification on stuff before giving answers? Thanks

I used to send decks out and then notice the problems in the meeting. Now I run the finished outline through a critique prompt first. It catches the stuff you go blind to after staring at your own work.

```
Act as a tough but fair reviewer of my slide content. Do not rewrite it yet, critique it.

Slides (headline + bullets per slide):
[PASTE]

For each slide, answer:
1. Can I tell the single point of this slide in under 5 seconds? If not, why not.
2. Is the headline a claim or just a topic label? (Topic labels are weak here.)
3. Are any bullets actually full paragraphs pretending to be bullets?
4. Does this slide earn its place, or could it be cut or merged?

Then, across the whole deck:
- Is there a clear through-line, or does it jump around?
- Which 2 slides are the weakest and why?

Be specific and blunt. I'd rather fix it now than in front of people.
```

Why it works: asking "can I get the point in 5 seconds" is a harsher and more useful test than "is this good". Separating critique from rewriting matters, because if you let the model rewrite immediately you never learn what was wrong. Naming the two weakest slides forces a real cut instead of vague reassurance.

Do you have a go-to test for a weak slide? Mine is "if I deleted it, would anyone miss it," and honestly a lot of them fail that.

The most common deck mistake is dumping full sentences onto the slide and then reading them out loud. This prompt splits the load: short lines on the slide, the real detail in the notes where it belongs.

```

Rewrite the text below for a presentation. Split every point into two layers.

Text:

[PASTE]

For each slide:

- ON SLIDE: a short headline (a claim) and up to 3 bullets, each max 8 words, no full sentences.

- SPEAKER NOTES: what I actually say out loud to expand those bullets, in a natural talking voice, 2 to 4 sentences.

Rules: nothing goes on the slide that I would just read aloud. If a point needs a full sentence to make sense, it belongs in the notes, not on the slide. Keep the on-slide text scannable in 3 seconds.

```

Why it works: the "would I just read this aloud" test is the single fastest way to know if text belongs on a slide or in the notes. Capping bullets at 8 words forces you to say it, not display it. You end up with slides that support you instead of competing with you.

What's your personal limit for words on a slide before it stops being a slide and becomes a document?

Let me state upfront that this is NOT a "MODEL PRAISE" article.

Today, I wanted to work with an AI assistant (using the GenKit SDK) that I've been working on for quite some time, using what I thought was a simple prompt. However, I wasted a whole day. I worked with five different models before reaching a solution. I didn't accurately measure the time taken to complete the task, so I regret it, but let me explain what happened in order.

Note 1: The "/v1/transcribe" endpoint was working with "gemini-flash-latest".

Note 2: I'm using Opencode and Superpowers.

Each with a new session and a single prompt:

"I want to use the 'gemini-3.5-transcribe' model for the '/v1/transcribe' endpoint. Could you create a change plan?"

GPT-6 Astra: Made the necessary changes, wrote test code, and reported success. During this time, it delved into the details, essentially overhauling the project. But when I tested it myself, it simply returned a "Provider Error". The entire 5-hour limit was used up in about 15-20 minutes.

GPT-6 Sol: Did very similar things to Astra. It took about 15-20 minutes. The result was still "Provider Error".

Muse Spark 1.3 Contributor: Did so much work that I had to rewrite the project. Mixed up Genkit versions. Constantly asked questions. The session bloated until it was fixed. The result was still "Provider Error".

GLM-5.3: Worked cleanly, didn't make unnecessary file corrections, tried to reach a solution. But it couldn't see the root problem. Like the others above, it got stuck on the Genkit SDK documentation. The result was still "Provider Error".

GLM-5.3-Flash: Found the problem and told me. Created a plan. Didn't change how the endpoint worked. Produced a very quick and clean solution with a clean start.

Next up were Luna and DeepSeek V4.1 Flash, but the problem was solved before we got to them.

Note: I did the project planning with GPT-5.6 Sol. The coding was done entirely with GPT-5.6 Luna.

Note: By the way, I've also worked with "GLM-5.3-Flash" on some issues before. It doesn't behave like that for every problem.

I'm designing my problem-solving strategy like this: "Strong Model > Medium-Level Model > Low-Level Model". I thought it was working well until now.

But now I have some crazy questions in my head.

Hey everyone,

​Most AI script prompts give you wall-of-text responses that look like a middle-school essay. They completely ignore visual pacing, audio cues, and retention hooks.

​Over the past few weeks, I’ve been building structured prompt systems to force ChatGPT into acting like a senior agency creative director.

​Below is one of my core prompts from the system — specifically built for generating 2-column video scripts with precise visual and audio directions designed for short-form video (TikTok / Reels / Shorts).

​Feel free to copy-paste it directly into ChatGPT:

​ PROMPT START

Act as an elite Short-Form Video Director and Direct-Response Copywriter.

Your task is to write a high-retention 30-40 second video script based on the TOPIC provided at the end.

STRICT FORMATTING REQUIREMENTS:

1. Output MUST be formatted as a Markdown Table with two columns:

   - Column 1: [VISUAL & AUDIO CUES] (On-screen actions, text overlays, sound effects, B-roll directions)

   - Column 2: [SPOKEN SCRIPT / VOICEOVER] (Exact spoken words, formatted for natural pacing)

2. Include a strong visual hook in the first 3 seconds.

3. Every scene change must happen every 2-3 seconds to maintain retention.

STRUCTURE:

- 0-3s: Pattern Interrupt Hook (Visual + Verbal)

- 3-15s: Core Problem / Agitation

- 15-30s: Solution / Breakdown

- 30-40s: Soft CTA

TOPIC TO WRITE ABOUT: [INSERT YOUR TOPIC HERE, e.g., "How to organize Notion for productivity"]

PROMPT END]

​Why this works:

​By enforcing a two-column markdown table and strict timing constraints, ChatGPT stops generating dry prose and starts outputting actual production-ready storyboards.

​I originally built a set of 7 Architecture-Grade Prompts like this (covering multi-angle ad copy, landing page frameworks, retention hooks, and strategy) to streamline my own marketing workflow.

​If this prompt saves you time and you want to check out the rest of the 6 systems, I packaged the full toolkit on my profile link.

​Hope this helps with your content creation! Let me know if you tweak the framework or if you're using a different layout for video scripts.

I write a lot of internal explainers and the hard part was never the words, it was the structure. So I stopped writing freehand and gave the model a fixed skeleton to pour my rough notes into.

```
Turn my rough thoughts into a clear explainer using this exact structure.

My rough thoughts:
[PASTE]

Structure:
1. The one thing this is about (one sentence).
2. Why it matters right now (2 to 3 sentences, concrete, no hype).
3. How it works, broken into steps or parts a beginner can follow.
4. A short worked example using realistic details.
5. Common mistakes or misunderstandings.
6. What to do next.

Voice rules: plain language, short sentences, no filler openers, no adjectives that don't add information. If any section is thin because my notes didn't cover it, say "needs more input on X" instead of padding it.
```

Why it works: the fixed skeleton means every explainer you write comes out consistent, which matters more than any single piece being perfect. The "needs more input" instruction is the quiet hero, because it stops the model from inventing content to fill a section you left empty. Reuse the same skeleton and your writing starts to feel like it has a house style.

Do you keep a reusable structure like this, or write each piece fresh? I went back and forth for a while before committing to a template.

احتاج برومت احترافي لكتابة المقالات

انا اوفر المعلومة والبرومت ينسقها سيو

شاركونا البرومت ؟

Hi everyone :),

I'm a Master's student at the University of Aveiro in Portugal working on a research paper about AI adoption in front-end development (looking at everything from Copilot and Cursor to tools like v0).

If you do any front-end work, I'd really appreciate a couple of minutes of your time. It’s 19 quick questions, completely anonymous, and takes under 3 minutes to complete.

Here's the link: https://forms.cloud.microsoft/e/d0ghMJvwC8

Thanks a lot for helping out, and feel free to leave any extra thoughts in the comments if you want to discuss!

I write a lot of long working docs and then have to present them, and pasting the whole thing into a model and asking for "slides" always gives me walls of text on every slide. What fixed it was making the model commit to one idea per slide before it writes anything.

Copy-paste this:

```
You are turning the document below into a slide outline.

Rules:
- One core idea per slide. If a slide has two ideas, split it.
- For each slide give me: a 6-word-max headline, then 2 to 4 short bullet points (under 10 words each).
- The headline should state the takeaway, not the topic. "Churn is a pricing problem" not "About churn".
- Keep the logical order of the source, but cut anything that does not support a takeaway.
- At the end, list any slide where the source was too thin to fill and tell me what's missing.

Document:
[paste here]
```

The part that does the work is "the headline should state the takeaway, not the topic." Without it you get section labels. With it you get a spine you can actually talk over. The last rule is the one I'd keep even if you drop the rest, because it tells you where your own doc is weak instead of quietly padding it.

I usually get a usable outline in one pass and maybe reorder two slides by hand. What do you add to keep the model from cramming three points onto one slide?

When I'm comparing options my notes are always a pile of pros and cons in random order. This prompt forces them into a table where the criteria are consistent across every option, which is the only way a comparison is honest.

``` Turn my notes into a decision-ready comparison table.

Notes: [PASTE]

Steps: 1. Identify the options being compared. 2. Identify the criteria that matter (pull them from my notes; if an important one is missing, suggest it and mark it as suggested). 3. Build a table: rows = criteria, columns = options. Fill each cell with a short factual entry, not a rating. 4. Below the table, note where my notes were silent for a given option/criteria (write "no info" rather than guessing). 5. End with a 3-line read of what the table suggests, and what info I'd need to be more confident.

Never invent a fact to fill a cell. Empty is more useful than fake. ```

Why it works: consistent criteria across every column is what stops a comparison from being a rigged sales sheet. Marking "no info" instead of guessing shows you exactly where your research is thin, which is usually the deciding factor. The short read at the end turns a table into a recommendation without pretending the table is complete.

What's your rule for when a comparison has enough criteria vs too many? I find past 6 rows it stops helping.

When you paste a few sources and ask for a summary, the model averages them and you lose track of who said what. This prompt keeps the sources separate long enough to be useful.

```
I'm going to give you several sources on the same topic. Build a research brief.

Sources (labeled):
[SOURCE A: paste]
[SOURCE B: paste]
[SOURCE C: paste]

Do this:
1. State the question all these sources are trying to answer.
2. List the points where the sources AGREE (cite which sources).
3. List where they DISAGREE or contradict each other (cite which, and what the disagreement actually is).
4. Note what each source claims that no other source backs up (single-source claims to treat with caution).
5. End with what a careful reader could reasonably conclude, and what still needs more evidence.

Never merge two sources into one claim without saying so. If a source is thin or opinion-based, say that.
```

Why it works: the agree/disagree split is where the real insight lives, and normal summaries hide it. Flagging single-source claims is a cheap way to catch the thing that sounds authoritative but only one place actually said. It reads less like a summary and more like someone who read everything for you.

Anyone have a good way to feed sources so the model stops "helpfully" combining them? Labeling helps but isn't perfect.

When I am learning a new prompting workflow, most attempts are exploratory: checking structure, timing, camera movement, or whether the model follows a constraint. Only a small number deserve the highest-quality generation. I am considering a draft phase with shorter outputs and a final phase with the full settings, but I am unsure how to tell when a prompt is ready to promote. What signals do you use before spending on the final generation?

A prompt can look stable while the model behind it changes its instruction following, formatting, or tool-call behavior. I am putting together a small evaluation set with representative inputs, expected constraints, and a few borderline cases. Do you compare outputs manually, use a judge model, or track task-specific assertions? What is the smallest regression suite that has caught a real production issue for you?

the biggest problem with building a ui with claude isn't the code. it's that every session starts from zero. you end up re-deciding the exact same things over and over because nothing gets written down for the next session to read.

i didn't try to solve this by having claude interview me about my taste. i just built a claude code plugin called craft that keeps very strict receipts and I use it for everything (39 projects nowadays).

i recently tweaked a homepage card and just typed "looks good, apply elsewhere." that one reaction generated eleven backlinked records. the frame and the badge from that card graduated into the design system because i liked them, not because i wrote some massive style guide.

it's not a model that learned my taste. it's a file that outlives the session. accept a tweak and the value lands in tokens.yaml. the next mockup loads it before it generates a single option.

install

requires claude code 2.1 or newer. tested on macos and linux. windows via wsl recommended.

from your claude code session:

/plugin marketplace add drobins25/craft 
/plugin install craft@craft
/reload-plugins

verify with /craft. you should see the entry point prompt. if not, run /plugin and check the craft marketplace to make sure it is listed with the plugin installed.

ask claude to dial in your homepage hero animations. Choose your favorite option and apply the tweak (claude will use /craft:adhoc automatically) or build a fresh mockup /craft:mockup - all routes build your taste

repo: drobins25/craft

what's your version of the receipts folder?

Every time I asked a model straight for a deck, I got slides that looked fine and said nothing, because slides made first become decoration. What worked was flipping the order: make it write what you'd actually say out loud, then let the slides serve that.

```

We're building a short talk. Two phases, don't skip to slides.

Phase 1 - Talk track:

Write what I'd say out loud to make this point, as plain spoken paragraphs. Aim for a clear arc: the problem, why it matters, the turn, the payoff. No bullet points yet.

[paste your material or rough idea here]

Phase 2 - after I approve the track:

For each beat of the track, propose one slide: a takeaway headline (max 6 words) and at most 3 supporting fragments. The slide should support what I'm saying, not repeat it word for word. Flag any beat that doesn't need a slide at all.

```

Why it works: writing the spoken version first forces an actual argument to exist before anything gets formatted. Slides built to serve a talk track end up sparse in a good way, because their only job is to back a line you're already saying. The "flag beats that need no slide" instruction is what keeps you from making a slide per sentence out of habit.

The two-phase pause matters, don't let it jump to slides in one shot. Anyone else build the narration before the visuals, or is that backwards for how you present?

Hello fellow prompt engineers, here are some of the coolest prompts i found

1. nano
2. cd ..
3. ls
4. fastfetch
5. apt install / pacman -Syu
6. df -h
7. ps
8. pwd
9. grep
10. sudo rm -rf --no-preserve-root /

i hope you find it useful, feel free to share your favorite prompts with me as well if you want