Meet4Specs

Turn user interviews into OpenSpec-ready development bundles — locally, privately, and with enough structure to move from conversation to implementation.

Quick Demo

Project Description

Meet4Specs is a local-first desktop application for product discovery and spec-driven delivery. It records user interviews, transcribes them on-device, generates AI summaries, and turns those conversations into OpenSpec bundles (proposal, spec, design, tasks) that development teams can actually use.

It builds on top of Meetily, reoriented from generic meeting intelligence toward requirements capture and specification generation.

Why This Project?

Most interview notes die in chat threads, docs, or scattered recordings. Teams lose context between discovery and delivery, then rewrite the same intent again when engineering starts.

Meet4Specs closes that gap. Instead of stopping at transcript or summary, it pushes one step further: interview → structured requirements → OpenSpec-ready artifact bundle. You keep privacy-first local transcription, but get output shaped for real product and engineering workflows.

Key Features

Feature	Description
Local-first transcription	Captures microphone + system audio, then transcribes interviews locally with Whisper or Parakeet models.
OpenSpec bundle generation	Produces structured proposal, spec, design, and tasks outputs from interview content.
Flexible AI providers	Supports fully local Ollama plus Claude, Groq, OpenRouter, and custom OpenAI-compatible endpoints.
Cross-platform desktop app	Built with Tauri for macOS, Windows, and Linux.
GPU-aware transcription	Uses Metal/CoreML, CUDA, Vulkan, HIP, or OpenBLAS depending on platform and hardware.
Downloadable deliverables	Exports generated specs as a .zip bundle ready for review or handoff.
Privacy-preserving workflow	Audio, transcripts, and local processing stay on your machine unless you explicitly choose a cloud model provider.

Technology Stack

Primary stack, sourced from project manifests and setup docs:

• Desktop shell: Tauri 2.6.x
• Backend: Rust edition 2021, minimum Rust 1.77
• Frontend: Next.js 14, React 18, TypeScript 5
• UI: Tailwind CSS, shadcn/ui, Radix UI
• Local database: SQLite via sqlx
• Transcription engines: whisper-rs 0.16.0, Parakeet via ONNX Runtime
• Local AI option: Ollama
• Build tooling: Node.js LTS >= 18, pnpm >= 8, Bun >= 1.1.43, CMake >= 3.x

Project Architecture

Meet4Specs is a self-contained desktop application.

flowchart TB
    subgraph app["Meet4Specs desktop app"]
        ui["Next.js UI"] <-->|Tauri IPC| rust["Rust / Tauri backend"]
        rust --> audio["Audio capture"]
        rust --> stt["Whisper / Parakeet transcription"]
        rust --> summary["Summary service"]
        rust --> specgen["OpenSpec generator"]
        rust --> db["Local SQLite storage"]
    end

    summary --> ollama["Ollama (local)"]
    summary --> cloud["Claude / Groq / OpenRouter / custom OpenAI"]
    specgen --> node["Node.js + npx openspec"]

Loading

High level:

• Next.js frontend drives interview, transcript, and settings UX.
• Rust/Tauri backend handles native audio capture, transcription, local storage, summaries, and OpenSpec generation.
• Node.js + OpenSpec CLI are used when generating the development-spec bundle.

See also docs/architecture.md and docs/DEV_SETUP.md.

Getting Started

Prerequisites

• End users: supported desktop OS and microphone
• Spec generation: Node.js LTS installed on PATH
• From source: Node.js, pnpm, Rust, Bun, CMake

Quick Start from source

git clone git@github.com:xmagcx/meet4specs.git
cd meet4specs/frontend
pnpm install
./dev-gpu.sh

CPU-only alternative:

cd frontend
pnpm tauri:dev

First-run flow

1. Open app and complete onboarding.
2. Download transcription model.
3. Configure AI provider in Settings.
4. Record interview or import audio.
5. Generate summary.
6. Click Generate development specification.

For OS-specific install and troubleshooting, see docs/GETTING_STARTED.md and docs/BUILDING.md.

Usage

Typical workflow:

1. Run an interview in Meet4Specs.
2. Capture microphone and optional system audio.
3. Review transcript and summary.
4. Export generated OpenSpec bundle.

Example of inspecting exported output:

unzip customer-discovery-spec.zip -d ./customer-discovery-spec
find ./customer-discovery-spec -maxdepth 3 -type f | sort

Expected bundle shape:

customer-discovery-spec/
├── proposal.md
├── design.md
├── tasks.md
└── specs/
    └── <capability>/
        └── spec.md

That output is designed to plug into a spec-driven development workflow instead of forcing teams to manually rewrite interview notes into engineering artifacts.

Product demos

Project Structure

Path	Purpose
frontend/	Next.js desktop UI, scripts, and frontend tests
frontend/src-tauri/	Rust/Tauri core: audio, transcription, storage, summaries, OpenSpec generation
llama-helper/	Rust sidecar binary for local inference support
docs/	End-user, build, architecture, and setup documentation
openspec/	Local OpenSpec workspace for specs and in-flight changes
backend/	Legacy backend archive retained for historical context, not current supported path
assets/	Branding and visual assets

Development Workflow

Current repo workflow, based on CONTRIBUTING.md and GitHub Actions docs:

• main = production branch
• dev = integration and testing branch
• Feature branches should branch from dev
• Pull requests target dev
• CI provides multi-platform build/test validation plus release automation

Useful workflow docs:

• Contributing guide
• .github/workflows/WORKFLOWS_OVERVIEW.md
• .github/workflows/README_DEVTEST.md

Coding Standards

Project conventions documented in CONTRIBUTING.md:

• follow existing code style
• use meaningful variable and function names
• keep functions small and focused
• add comments for complex logic
• update docs when behavior changes
• use structured commit messages such as feat(scope): subject

Testing

Testing is mixed by layer:

• Frontend: tests live under frontend/tests/
• Rust backend: extensive unit and async tests live under frontend/src-tauri/src/
• CI: GitHub Actions validates cross-platform builds and release flow

Contributor expectation:

• add or update tests for new behavior
• ensure relevant tests pass before PR
• update docs when feature behavior changes

Roadmap

Current direction, based on existing docs and repo intent:

• Multi-Modal Image Ingestion Pipeline
  • Support uploading meeting screenshots, whiteboard sketches, UI mockups, and architecture diagrams alongside audio/transcripts.
• Vision LLM Integration (Llama 3.2 Vision / LLaVA)
  • Implement vision model integration to analyze and extract contextual software engineering detail from uploaded images.
• Diagrams-as-Code Engine (Mermaid.js / PlantUML)
  • Automatically parse visual input (flowcharts, sequence diagrams, ERDs) and convert them into standard Mermaid.js or PlantUML markup embedded directly into generated specification deliverables.
• Ultra-Fast & Lightweight ASR Engine Support (SenseVoice / Moonshine)
  • Integrate alternative open-source speech-to-text models for local, low-latency, and resource-efficient processing.
• Dynamic Model Router
  • Route audio files dynamically based on language, duration, compute resources, or latency targets (e.g., fast local transcription vs. high-accuracy cloud Whisper).
• Loudness Normalization (LUFS)
  • Implement dynamic range compression and Integrated Loudness Normalization (target: -16 to -14 LUFS) to balance low-volume whispers and loud speakers, preventing word omission or signal distortion.
• Noise Suppression (Spectral Gating / RNNoise)
  • Filter out background HVAC hums, fan noises, desktop vibrations, and ambient static before feeding audio into ASR models.
• High-Pass Filter (HPF @ 80 Hz)
  • Remove low-frequency rumbles, microphone thumps, wind noise, and physical table knocks below 80 Hz.
• Voice Activity Detection (VAD - e.g., Silero VAD)
  • Strip non-speech audio and extended silences prior to transcription to eliminate hallucinations, repeated loops, and unnecessary API token consumption in Whisper-based models.
• ASR Accuracy Evaluation Plugin (Standalone / Auxiliary Tool)
  • Implement Word Error Rate (WER), Character Error Rate (CER), and Match Error Rate (MER) benchmarks to quantitatively measure transcript accuracy against ground-truth references.
• Specification Consistency & Completeness Validator
  • Automated LLM-as-a-Judge validation layer to verify whether requirements, acceptance criteria, and technical constraints generated in the specifications strictly match source transcripts and visual diagrams without hallucinations

FAQ

Does audio leave my machine?

Transcription can run fully locally. Summaries and spec generation stay local if you use Ollama; cloud providers are optional.

Do I need Node.js?

Only for the Generate development specification feature, which invokes the OpenSpec CLI via npx.

Is the old backend/ folder still supported?

No. It is retained for historical reference. Current supported architecture is the Tauri desktop app.

Contributing

Contributions welcome. Best path:

1. Open or confirm issue first.
2. Branch from devtest.
3. Keep change focused.
4. Add or update tests.
5. Open PR against devtest and complete template.

For details, read CONTRIBUTING.md. If the repo starts labeling onboarding issues, good first issue is best place to begin.

Author & Contact

Mauricio Gallardo

License

Distributed under the MIT License. See LICENSE.md.

Star History