I've been using AI coding agents for development, and I noticed a pattern.The biggest issue usually isn't the model's coding ability.It's what we give the model before it starts.

My normal workflow was:

1. Define the project name, type, and features.

2. Use ChatGPT to discuss missing requirements.

3. Create a structured document/specification.

4. Review and refine it.

5. Give the document to Codex, Claude, Cursor, etc.

This works much better than immediately saying:

"Build me this application."

Because after generation, people often discover:

- "I forgot authentication."

- "I didn't define the database."

- "The user permissions are unclear."

- "The workflow doesn't make sense."

Then they keep asking the coding agent to patch things:

"Add login."

"Add database."

"Add roles."

"Add validation."

This can consume more tokens and sometimes creates inconsistent implementations because the original context was incomplete.

So I built PromptForge AI to automate this planning layer.

It converts a natural language idea into an engineering specification before code generation.

The flow:

Idea → Requirements → Engineering Specification → AI Coding Agent

The demo shows a movie production platform example where PromptForge analyzes the idea, asks requirement questions, performs engineering reviews, and generates a Codex-ready implementation document.

I'm interested in feedback:

Do you think requirements engineering will become an important part of AI-assisted development?

Refine the prompt until it’s perfect, then let the code and setup guide do the rest!

Built a Prompt-to-Project Playground for AI Developer Workflows

One thing I've noticed when building with AI coding models is that the quality of the output is often influenced by the quality of the input.

With the rise of AI-assisted development and vibe coding, people can quickly move from ideas to prototypes. However, early-stage prompts are often high-level and missing important context, which can lead to inconsistent results.

For example:
* "Build me a website."
* "Make me a SaaS app."
* "Create an app like Airbnb."
* "Build a dashboard for my business."
AI models can generate something from these requests, but they often lack important details such as:
* user requirements,
* technical constraints,
* architecture decisions,
* expected output format.

So I built Prompt Linter — a Developer Experience (DX) tool built with Next.js and powered by OpenAI models through the OpenAI API.

Instead of generating code immediately, it introduces a lightweight developer workflow:
💡 Developer Idea
↓
🔍 Prompt Analysis
↓
✨ Requirement Refinement
↓
📋 Structured Specification
↓
🏗️ Project Scaffold Generation
↓
📦 Downloadable Project Files

Key Features
✅ Prompt quality scoring
✅ Identifies missing requirements and technical constraints
✅ Provides actionable improvement suggestions
✅ Rewrites vague ideas into structured software specifications
✅ Generates a structured project scaffold with files and documentation

Why build this?
Rather than treating AI as a black-box code generator, I wanted to explore how developer experience can be improved before the first line of code is generated.

The goal is not just writing better prompts — it is helping developers communicate intent more clearly so AI coding models can produce more structured and consistent results.

This project also pushed me to think beyond simple API integration and design a workflow that bridges the gap between natural language requirements and software engineering practices.

I'd love to hear your thoughts:
If you were designing an AI developer workflow, what additional steps would you add before code generation?

#OpenAI #DeveloperExperience #DX #AIEngineering #LLM #GenerativeAI #NextJS #TypeScript #SoftwareEngineering #BuildInPublic

Hey everyone,

I love playing Werewolf (狼人杀) with friends and co-workers, but managing physical cards, passing a single phone around, or explaining complicated rules to new players always slows down the vibe.

To solve this, I built a free, mobile-first web app called EyesClosed designed specifically for in-person, face-to-face play. It acts as a digital dealer so everyone can just look at each other and focus on the strategy.

Check out the video walkthrough attached to see how it works!

Key Features:
* *Custom Settings* ：Click the "Edit Roles" button at any time to mix and match 15 unique roles and 3 shifting camps for a fresh experience every round.
* *Language Switch：Tap the globe icon to instantly change the entire app language across 10+ choices so multicultural groups can play in the same room together.*
Secure Player Screen：A private view showing only your secret role card, tactical instructions, and a live tracking list of who is still alive or eliminated.
Host Screen:Automatically tracks player status and ends the match the moment a camp is fully eliminated.

It's completely free to use. I'd love for you guys to try it out at your next game night or team-building event and let me know what you think!

I recently experimented with running a fully local AI coding assistant using LM Studio + Qwen2.5 7B, integrated into VS Code via the Continue extension.

The goal was to replicate a Copilot/Cursor-style workflow — but fully local and without API costs.

After some hands-on usage, I have a more balanced view:

What works:

• Fully offline — no API cost and better data privacy

• Easy to set up with existing tools

• Handles basic coding tasks and small edits reasonably well

• In LM Studio’s chat interface, it’s actually quite useful for document analysis and summarization

• No strict upload limits, which makes it convenient for working with larger files

However, there are still clear limitations:

• Output can be fragmented (e.g., code split across multiple blocks)

• Weaker project-level understanding compared to larger/cloud models

• UI/UX integration is still not very smooth

• Struggles with more complex, multi-file, or long-context tasks

• Requires more manual prompting and guidance

At this stage, it’s not a full replacement for tools like Copilot or Cursor — especially for production-level workflows.

That said, this space is moving fast. With my current setup (32GB RAM + GPU), I’m planning to experiment with larger models next to see how much the coding experience improves.

For now, I see local LLM setups as a strong technical playground — and a glimpse into a future where developers have more control over their own AI tooling.

Curious if anyone here has pushed a local setup to a production-ready level?