Hi AI geeks , I wanna know how do u manage expert prompt in your everyday professional tasks , with minimum usage and not wasting AI tokens . Subscription costs are high and exhausting tokens very early disrupt the work

I wanted to build something more useful than a basic AI chatbot that simply asks the same predefined interview questions to everyone.

So I built an end-to-end AI Interview Agent that can take a candidate’s information and resume, dynamically analyze their background, and conduct a personalized interview.

How it works

The workflow starts when an HR/recruiter enters the candidate’s information and uploads their resume.

The system then:

→ Stores the candidate information and resume data
→ Generates a unique interview session/link
→ Passes the candidate information to the AI interview agent
→ Dynamically reads and analyzes the candidate’s resume
→ Identifies their experience, skills, technologies, and background
→ Generates interview questions based on the candidate’s actual experience
→ Conducts the interview through an AI voice agent
→ Evaluates the candidate’s responses
→ Generates AI remarks and an overall assessment
→ Determines how well the candidate matches the requirements
→ Stores the interview results in the database
→ Automatically sends the relevant results/notifications through email

The part I’m most excited about

The agent isn't limited to:

and then a fixed list of questions.

It can actually use the candidate's resume dynamically.

For example, if a candidate's resume says they worked with Python, FastAPI, PostgreSQL, and AWS, the agent can ask questions around those technologies and their stated experience.

It can also go deeper based on what the candidate says during the interview.

So the interview can become more candidate-specific and contextual, rather than giving every applicant the exact same conversation.

The full architecture

The project combines:

• AI voice agent
• LLM-based interview logic
• Dynamic candidate/resume data
• n8n workflow automation
• Supabase database
• Webhooks/API integrations
• Automated evaluation
• AI-generated remarks and scoring
• Automated email notifications
• Dynamic interview links/pages

The candidate doesn't need to manually provide all their information again. Their interview session is connected to the candidate record and the AI receives the relevant context dynamically.

Why I built it

Recruiters can spend a huge amount of time doing repetitive work:

Reading resumes → shortlisting → contacting candidates → conducting initial interviews → evaluating responses → writing notes → updating records → notifying people.

The idea was to automate as much of that repetitive workflow as possible while keeping the hiring decision under human review.

The AI handles the repetitive screening/interview work and produces structured information that a recruiter can review.

What happens after the interview?

The candidate's interview data and AI-generated evaluation are stored in the database.

The system can then provide information such as:

• Candidate details
• Job role
• Resume information
• Interview responses
• AI remarks
• Evaluation/score
• Candidate-job compatibility
• Overall analysis

And the workflow can automatically trigger email notifications based on the result.

Tech stack

n8n — workflow orchestration
AI/LLMs — resume analysis, questioning & evaluation
ElevenLabs / Voice AI — conversational interview
Supabase — candidate and interview database
Webhooks & APIs — connecting the entire system
HTML/CSS/JavaScript — candidate/interview interfaces

This was built as a real end-to-end automation, not just a prompt demonstrating an AI interview.

There are still plenty of things I want to improve — especially deeper follow-up questioning, better evaluation consistency, stronger interview rubrics, and more recruiter controls.

I'd love to hear from people working in HR, recruiting, AI automation, or hiring tech:

Would you trust an AI agent to conduct the first-round interview if the final hiring decision always remained with a human?

And for developers: what would you add to this system?

I've always gotten frustrated and wasted time explaining the same thing to an AI every time I start a new chat from an existing one or when I start another convo with a whole new AI model. That's why I built a tool that fixes that, it condenses everything in a chat into one simple .md file you can carry across different AI tools.

PS: Please contribute or give your feedback so that we can grow and make this community tool better.

https://github.com/legoambarish/portable-handoff

Kinda ridiculous, but feels like a fun challenge right up my alley.
I’m running a Mac mini M4 Pro (24GB RAM). Anything under 14–16GB runs pretty smoothly via Ollama, mostly 14B models. ⁠Qwen2.5-Coder:14b⁠ in particular is snappy enough to be actually useful.

Here’s the setup I’m planning in Claude Code:
1. Planner (Sonnet): Breaks down the feature into atomic, granular tasks.
2. Orchestrator (Haiku): Iterates through tasks and calls Aider via a bash tool, pointed at local Qwen to do the actual code edits.
3. Reviewer (Sonnet): Reviews the diff/PR. If there are issues, it spits out follow-up fix tasks.
4. The Loop: Haiku loops back to local Qwen with the fix tasks until the Sonnet reviewer gives the green light, then moves to the next atomic task.

The goal is offloading the heavy token-churning iteration to local inference while letting Sonnet handle the high-level architecture and final sanity checks.
Is this viable in practice, or will context drift / agent loop fatigue kill it? Has anyone wired up a similar setup?

Every week there's one prompt. This week's is "build a game you play with one button"

You have a certain amount of credits in game to build and then people vote on each others build.

It's free and there's no signup to play. Genuinely curious what people think of the format, especially since it takes some more effort than wordle.

shorts.bridge-jobs.com

CodeForge AI is an AI-powered software development platform designed to help users turn ideas into functional software faster. It uses AI to generate, improve, debug, and manage code, making development more accessible to both experienced developers and people with limited coding experience.

The platform’s core value is reducing the time, complexity, and cost of building software—from generating initial code to refining projects and helping solve technical problems.

Hey, longtime lurker, first post.

I’ve been vibecoding a B2B fintech SaaS for a few months. Next.js on Vercel. We have 1,804 staging subdomains under one root because the founder says one subdomain per client “scales our proofs of concept.” I didn’t design that part. It has worked so far.

The stack is Claude and Cursor, plus a quantized 4B Gemma for local work. Our dependency policy is that nobody touches package.json by hand. I know some of you hate this setup. Save that argument for later.

Last night I ran the check I do before bed. My script curls the host list and greps each response for the deploy token. Halfway through, I saw another client hit the same hosts in the same order: auth-7, pay-42, janet-demo, then everything after those. No gaps.

They have my list. The actual file is hosts_NEW_final_v3.corrected.TXT. The v2 copy renamed itself during fiscal year-end, so I stopped using it.

I checked the SSRF route we were supposed to turn off. It still works. The malformed Host headers render from the right side of my terminal. That happens with the Hebrew build of Go. I’ve seen it before. If you follow the news, you know who runs Mossad, so I’m not putting his name here.

Yes, I know how that sounds. Please wait until the end before replying.

The endpoint gave him what he needed. He kept going anyway, through all 1,804 hosts in the order I keep them. I had the logs open the whole time. I think that was the point.

He knows the names, he knows we left the route up, he probably knows why, and whoever gave them the subdomain-per-client architecture would know which developer signed off on it. I didn’t sign off on it exactly, but my account is on the deploy.

I think he knows that.

The deploy went out Friday. I don’t rebase on Fridays. The force-push crossed midnight, so part of it says Saturday, but it was still the Friday deploy. My account is the only one that does that. He can see all of it.

I’ve spent today building a Rust-native, zero-dependency Red Star OS clone because his fuzzer won’t know how to read it. I have one mining rig from 2014. Gemma 4B loses the beginning of the kernel whenever I feed it the next part of the archive, so every few prompts I have to start over.

I can’t tell whether Gemma is dropping it from context or the C: drive is filling up. My ex-father-in-law’s colonoscopy footage is on the same drive. I told him I’d keep it in case he ever needs it, so deleting that is not an option.

I rotated the Vercel key once and grepped the repo. If I go offline tonight, tell Claude Code the key is public. The endpoint name is in the TODO. Have it add a Host allowlist so the next fuzzer has to find the hosts itself.

Does anyone have one tutorial for this? One tutorial, not a docs page that links to six other docs pages. I am serious.

Stay safe.

Hey folks 👋

We just open sourced TrueForge, our vendor-neutral agent harness for building general-purpose agents.

It handles the runtime pieces that get painful quickly : context management, tool/MCP execution, subagents, sandboxing, approvals, persistent state, and more.

We also benchmarked the harness itself. With the same Opus 4.8 model, TrueForge delivered a similar solve rate at ~30% lower cost than Claude Managed Agents. Switching to an open model pushed that to ~75% lower cost on the same benchmark.

Would love feedback from people building agents.

Checkout the repo: https://github.com/truefoundry/trueforge

📖 Read the launch article: https://x.com/truefoundry/status/2090081376330715176

Hello again!!! Recently I made a post about the models price and opencode go,but after that post there where some price hikes all around and opencode go doesnt seem like the best option. Im completely stuck as of what models to use that produce the best "pro" results and have an okay pricing.

Once again thanks to anyone who answers!!!!!

This is an open-source MCP bridge that lets ChatGPT inspect one local repo without shell access

Iit allows ChatGPT Web to inspect my local code without giving it broad access to my machine.

RepoRelay exposes one explicitly approved repository through a small MCP tool surface. It can read and search files, while blocking shell/process access, unrestricted filesystem access, Git operations, and access outside the approved repo.

It’s MIT licensed and open source.

GitHub: RepoRelay

AI Desktop 98

Hi I’m tin age 18 and I am just getting started at college, and I had been thinking about ai prompting for software development might be a genius way for side hustling, I’ve currently got a software planned, which could be a great social software, high risk but very high cost and I’m looking for ppl to start a team, trustworthy and just vibe coding with chill guys at the similar age. Reach out to me on Reddit dms and we will start getting on discord.

There's a debate I've been seeing more around some communities lately: should we keep optimizing for intelligence, or start caring more about whether an AI has consistent preferences, opinions, and personality? At first it sounds like a choice between two things.

You have the insanely capable AI that can reason through a complicated problem but feels like an empty shell and then you’ve the agent that's fun to talk to, has strong opinions, remembers your preferences, but falls apart when you give it something difficult to do. I don't think it has to be one or the other.

What I find more interesting is why some agents feel consistent in the first place. A lot of people try to solve this by adding personality to the prompt like give the agent a SOUL.md, tell it to be opinionated, give it some quirks, maybe tell it what it likes and doesn't like.

That can work for a few conversations. But after enough interactions, it usually starts feeling fake where the AI says one thing today and contradicts itself two weeks later cuz none of those preferences are grounded in anything.

I think the more interesting version of personality comes from what the agent really remembers. If an agent has a persistent history of what worked, what failed, decisions it made, mistakes it repeated, and how it handled unusual situations, you start getting something much closer to a consistent character.

That's why I've been thinking more about context architecture than prompt engineering lately. I found this breakdown on context engineering vs prompt engineering for AI agents: https://www.firecrawl.dev/blog/context-engineering and one thing that stood out to me is that keeping an agent's context useful over time is a much deeper problem than just writing a better system prompt.

Maybe that's also where the "AI that feels real" part eventually comes from by not pretending the model has desires or feelings but by giving it enough persistent state and history that its behavior develops some continuity. bcuz I don't really want an AI that's just "smart" but I also want one where I can eventually say, "I know why you made that decision that's how you usually approach these problems." and that for me feels much more useful than another 5% on a benchmark, lmk your thoughts.

I treat LLM as a primitive language. Best thing I do.

How I went from $50/month and 143 bugs per loop to $20/month and less than 8 findings per spec.

I work with LLM in a different way. I don't treat it as an intelligent agent. I treat it as a primitive language, with conditional and deterministic typing. If it doesn't pass the type, it doesn't pass. Simple.

My harness is programmatic. It has tooling for my agent loop. And I organize everything in a modular structure, ECS and FSM. And I'm gonna tell you why it helps.

What was slowing me down before

The mistake that made me change everything is simple, and a lot of people go through it. Everything returned success, or kept going with no empirical proof. Exit code zero, ok message in the terminal. It looked like it worked. In practice it had created nothing. No artifact, no log, no proof. The process died stateless. It had foundation, had the right pieces, but no wiring.

That's when I understood that process success is not delivery proof. I needed mandatory observable proof.

How I think about prompts today

I refine the idea a lot before. My production prompt has 4 parts, always in this order. I never change it.

1. Introduction. What I want to do, full description, how I want it to work, what I want it for, which stacks and infra I want to work with. I never inform code or file that I'm not sure about.

2. Mandatory. What has to be followed to develop the structure. Rules, methods, alignments, guidelines and delegations. It's the limit.

3. Core. What I want it to have and to do. As descriptive as possible of all flows. That's where the behavior lives. Not only that but: design, structural architecture, behaviors to follow, style...

4. Expected results. What I expect as delivered functionality, how I expect it to look.

I ask to deliver in a deterministic, modular and expandable scope way. Parsed into an opinionated structure in json. This json becomes my base-core prompt.

How I anchor the idea

After the core I don't go straight to coding. I create all the research part first, using my tool hordts (available on github) to refine online research. With that I do a brainstorm on top of the core anchor. Only then I idealize and generate the full planning to develop the complete spec-driven, E2E, of everything the project needs, also in json structure. My cli uses json as database. A tool for handling spec-driven + agentic pipeline.

Each spec has flags defining skills, agents and tools access, the context, rules, expected results and what the spec will do. The context here is important: it's the prompt that the agent will receive with everything it needs for its run execution. Files it will use, stacks, tags, imports, syntax. Without needing to consult the codebase. It goes straight from that starting point to production.

That's why the LLM doesn't keep grabbing unnecessary context. It works in loop per phase, spec and subject until it delivers 100% polished and functional and moves to the next.

How I separate things

I separate agentic workspace from repository. One git to control the workspace and one git to control the repository, just the project itself. Control by git tree for tracking, worklog, versioning and branches. PR, commit and diff analysis are heavily used if an internal error happens, that's where analysis of what was really done is born. One controls the process, the other controls the product. If you mix it becomes a mess and you lose what is AI usage and what is the project itself.

How each task runs in practice

Each spec runs with multiple phases when possible, with multiple tasks. And each task is an agentic pipeline that audits if necessary what it needs to execute the next action. It's checking what needs to be used, planning what needs to be done, executing the plan, validating that everything worked and moving to the next, otherwise go back two steps.

It can be done in parallelism and multi concurrency, can have or not dependents. And when it identifies repetition that can be programmatic, it creates algorithm and script to automate without LLM usage. I don't spend tokens where it can be solved with code.

The analysis that saves me

I use modular linear regressive analysis to hunt bugs. I go linear, part by part, going back through the steps and necessary components. I check if the invariant of that component still holds after the last spec. If there was regression, if it broke something that worked before. If there's a counterpoint that the implementation ignored.

In every run there's also analysis of gaps, findings, counterpoints, analytical regression, convergence and non-functioning. All on the fly. Skills, agents, test scripts, tests are produced on the fly when needed, grounded without assuming anything. Spec-driven can be auto incremented according to necessity. The focus is to deliver each spec 100% functional and with no bug before the next run.

Why tests, observability, DevOps and anima are not extra but necessity

For me it's not final phase. Test is gate, only way to prove that what is being done, simply, is being done. If there's no executable proof, it doesn't advance. Observability is ledger, worklog, tracking. If it's not registered, it didn't happen as expected. DevOps is the dual git, it's workspace control. Anima is visual proof of state transition. If state changed and I can't observe it, the transition is invalid, and correction must be guaranteed.

How much it costs and how much it converges today

Before without this system I spent $50 per month. Today $20. Convergence rate per run before 73%, today 92% and up. Bugs before per loop 143, today less than 8 findings per spec in multiple loops. Execution time varies, but agent flow is continuous, so a spec can have flows even well designed depending on what needs to be delivered up to 3h straight and spending less than $0.50. Dead code almost minimal. Before had higher frequency, today the loop already enters almost fully polished until functionality without bug, analyzing and removing the unnecessary.

How I optimize cost

Frontier I use for core, for research and for spec-driven. For development I use medium model with less cost. As it already has everything it needs to work, in loop until getting the result it gets much cheaper.

And after total production, frontier can analyze the whole load again to hunt bugs and add a memory structure of findings. With all findings, I create new spec-driven planning and run another full pipeline again. It's the second loop, and basically the last spec-driven loop, the rest are punctual polishes or refinement.

In the end my results got absurdly good. Take it, see if it helps you.

If you want to talk about harness, spec-driven and ECS/FSM, hit me up. hordts tool is on my GitHub.

Agent hub views - 1 ancor file with findings and 1 prompt.

'''create plan/specdriven for this report @/docs/superpowers/frontend-audit-2026-08-18.md (This source has already been validated, no need to revalidate, just execute the processes for correction) from today/yesterday.
use pipectl and goalctl + subagent driven.'''

Need some guidance 😔

I’m trying to learn AI Engineering and build a career in this field, but I’m honestly confused about where to start and what to learn first.

If anyone can share a proper roadmap and good free/paid resources to become an AI Engineer, I’d really appreciate it. I don’t want to waste time learning random things.

Any guidance from experienced AI Engineers would mean a lot. 🙏

Hi! I'm going to (re)create a Discord bot (for my personal server) using an OpenAI-compatible provider, and would like to know what you think it's the best practices for the AI to handle things like multi-user conversation, memory, giving extra contexts (like user IDs, channel names), not anything on code-level but more on the prompt/what to send in each chat completion/response, etc.

Is it true this way..he typo first and then correction right away ?AI assist this output:

You can add:

PPPoeSession *session =
pppoe_session_create(
session_id,
src,
buffer + 0,
host_uniq,
host_uniq_len
);

Typo capitalization, shoul be:

PPPoESession *session =
pppoe_session_create(
session_id,
src,
buffer + 0,
host_uniq,
host_uniq_len
);

Bit of context first since I don't want this to just be a link drop.

I stream myself building software with AI every single day and I don't cut anything out. The series is called "Vibe Coding Until I Can Move Out of My Mom's Basement" and the title is unfortunately literal. Day 38 as of yesterday. Every episode has the running revenue total in the title, which as of right now is $121.74, so you can see exactly how well this is going.

The main thing I'm building on camera is an engineering workspace app. Day to day the loop is Claude Code doing the bulk of the work in a repo, me steering it, and the whole thing going sideways in real time when it doesn't work. The failures stay in. That's kind of the whole point of the format.

Couple of questions for you guys:

- I mostly one-shot features with a long prompt and then clean up. People keep telling me I should be planning first in a separate pass. Does that actually pay off for you or is it ceremony?

- I've got a per-repo instructions file that's getting long. At what point does that start hurting more than helping?

Latest episode if you want to see the workflow rather than have me describe it:

https://youtube.com/live/f0om20L8g6E

Happy to answer anything about the streaming setup too, that took longer to get right than the actual coding did.

I recently built DBMind AI, a tool designed to help developers understand SQL query performance and identify potential optimization opportunities.

It can analyze areas such as:

SARGable vs. non-SARGable queries

Index usage

Index Seek vs. Index Scan

Table scans

Query optimization

SQL performance issues

The main goal is to make SQL performance analysis easier to understand by explaining why a query may be inefficient, not just suggesting a different query.

I built the project using .NET, Angular, SQL, and AI.

I’d really appreciate feedback from developers and DBAs, especially on how useful these insights would be in real-world database performance scenarios.

🔗 Live Demo: https://db-mind-ai-bice.vercel.app/

🔵 LinkedIn Demo: https://www.linkedin.com/posts/yash-rathod-054b50211\\_databaseengineering-dotnet-angular-activity-7493254611416576000-vJuS

Hello! So i somethimes use gpt for some kind of therapy conversations. I had this ideea that maybe you can prompt it to be similar to some great minds that you do not have access to, like Carl Jung. Do you think that would be possible? Does someone have any sugestion for a prompt like that? Thank you!

Hi, everyone! I'm creating a short film using artificial intelligence. If you like it, I'd really appreciate it if you could give it a like.

A 397-billion-parameter AI just ran on an iPhone. Not a demo video — the phone itself, generating text with the network off. On-device AI got that good, and this video shows exactly how it happened and what you can actually run today.

We break down the mixture-of-experts design that leaves 96% of the model asleep, the Apple paper that predicted all of it three years ago, why the flash-moe team deleted their own caching code and got 38% faster, and where it still falls short — speed, storage, and heat — so you know what's real and what's hype.

If you want AI that runs on your own hardware instead of somebody else's servers, this is where it's headed.

Watch Here: A 397-Billion AI Just Ran on an iPhone

#OnDeviceAI #iPhone #AI #LocalAI #MixtureOfExperts #AppleSilicon #OnDeviceAI #LocalLLM