AstraForge

Design, analyze, and iterate vehicles in one engineering workspace.

AstraForge is a bilingual AI-powered automotive engineering platform for teams that need to create new vehicle concepts, import existing CAD and reference files, inspect components in 3D, and run early-stage engineering analysis in one shared workspace. It helps automotive engineers, designers, startups, and students move from concept to review faster while keeping revisions, assumptions, and validation traceable.

Business Goals

  • Reach 300 active teams within 6 months of launch, with at least 35% converting from trial to paid plans.
  • Reduce average time from project creation to first usable engineering review by 50% within 90 days of adoption.
  • Achieve 40% monthly retention among active engineering teams by month 6.
  • Keep support tickets related to import, revision, and export workflows below 8% of total monthly usage events.
  • Deliver at least 2 enterprise pilot deployments with organization-level permissions and audit logging in the first year.

User Goals

  • Create or import a vehicle project in under 10 minutes.
  • Inspect vehicle components in a shared 3D workspace with preserved file provenance.
  • Generate early engineering calculations and audit findings without manual spreadsheet work.
  • Maintain revision history so design changes can be compared and restored safely.
  • Collaborate in English or Hindi without losing project context or unsaved changes.

Non-Goals

  • Replacing dedicated CAD kernels for full parametric modeling in V1.
  • Providing validated crashworthiness, homologation, or manufacturing certification outputs.
  • Delivering real-time multi-user simultaneous CAD editing in the first release.
  • Supporting every possible file format or solver on day one.

Priya, Automotive Design Engineer, 34 - Priya works at a mid-size EV startup and needs one place to review imported geometry, compare design revisions, and generate quick engineering notes for her team. She cares about data traceability, collaboration, and not losing source files.

Priya, Automotive Design Engineer, 34

  • As a design engineer, I want to import STEP and reference images into one project, so that I can review geometry and concept references together.
  • As a design engineer, I want to inspect components and see revision history, so that I can understand what changed and why.
  • As a design engineer, I want to switch the interface to Hindi or English, so that different team members can work comfortably.

Arjun, Mechanical Engineering Lead, 41 - Arjun is responsible for vehicle packaging, engine assumptions, and early performance review. He needs unit-aware calculations, confidence flags, and clear limits on what has actually been validated.

Arjun, Mechanical Engineering Lead, 41

  • As an engineering lead, I want to enter engine assumptions and get basic calculations, so that I can screen concepts early.
  • As an engineering lead, I want audit findings to include evidence and confidence, so that I can prioritize real risks.
  • As an engineering lead, I want simulation outputs to preserve inputs and solver configuration, so that results are traceable.

Maya, Product Manager at an Automotive Startup, 29 - Maya coordinates design, engineering, and leadership reviews. She needs a clean dashboard, project sharing, and exportable reports to keep stakeholders aligned.

Maya, Product Manager at an Automotive Startup, 29

  • As a product manager, I want to create projects and assign collaborators, so that the right people can access the right vehicle data.
  • As a product manager, I want to export reports and summaries, so that I can share updates with investors and partners.
  • As a product manager, I want to see project status and revision timeline, so that I can track progress without chasing engineers.

Authentication and Access Control · High priority

  • Provide secure user authentication, organization membership, and role-based permissions across projects and workspaces.
  • Support email/password login with secure session handling and password reset.
  • Store user language preference and organization membership in the profile.
  • Enforce project-level roles such as view, comment, edit, and admin.
  • Log all permission-sensitive actions in an audit trail.
  • Block unauthorized access to project files, exports, and revisions.

Project and Vehicle Data Management · High priority

  • Create a single source of truth for projects, vehicles, components, revisions, and imported assets.
  • Support create, edit, duplicate, archive, delete, search, filter, and sort for projects.
  • Assign stable UUIDs to projects, vehicles, components, revisions, and files.
  • Preserve original uploaded files without overwriting source geometry.
  • Track project metadata, ownership, collaborators, and status.
  • Maintain normalized relationships between vehicle, assemblies, components, and reports.

Import, Reconstruction, and 3D Visualization · High priority

  • Import supported CAD and image files, process them safely, and render real geometry in an interactive 3D workspace.
  • Support drag-and-drop upload, validation, progress, and failure handling for STEP, IGES, STL, OBJ, GLB, DXF, PDF, PNG, JPG, and JPEG.
  • Store file metadata, scale detection, and processing status separately from the original file.
  • Render imported geometry in Three.js and React Three Fiber with selection, isolation, visibility toggles, and screenshots.
  • Show missing or unsupported geometry states honestly, without fabricating model data.
  • Use background workers for conversion and analysis jobs so the UI stays responsive.

Engineering Workspaces and Calculations · High priority

  • Provide focused workspaces for engine, exterior, paint, parts, and preliminary analysis with validated calculations where available.
  • Implement engine inputs, physically plausible calculations, and charts for torque and horsepower.
  • Support component hierarchy, assembly tree, dimensions, materials, and weights.
  • Provide preliminary AI engineering audits with findings, severity, confidence, and evidence.
  • Separate concept generation from verified engineering geometry and calculations.
  • Mark results stale when upstream data changes.

Reporting, Export, and Collaboration · Medium priority

  • Allow teams to generate reports, export supported formats, comment on projects, and share work with controlled permissions.
  • Generate project overview, component, audit, and simulation reports with assumptions and sources.
  • Export only formats supported by the underlying data and conversion service.
  • Provide comment threads and activity logs for project collaboration.
  • Support report and export permission checks by role.
  • Track revision attribution and restore actions for auditability.

New User Onboarding

  • Sign up or sign in with email and password.
  • Choose English or Hindi and save the preference to the profile.
  • Create a new project or open an existing one from the dashboard.
  • Upload a reference file, CAD file, or text-based vehicle brief.
  • Review the imported or generated vehicle summary and open the 3D workspace.
  • Reach first meaningful project value within 10 minutes, such as a visible component tree, project summary, or initial calculation.

1. Dashboard and Project Setup

  • Users land on a dashboard that shows recent projects, status, and quick actions for creating or importing vehicle work.
  • Show loading, empty, and error states with clear recovery actions.
  • Validate project name, category, and ownership before creation.
  • Keep dashboard responsive with server-side pagination and filters.

2. Create or Import a Vehicle

  • Users either enter a structured concept brief or upload CAD and reference files to start a project.
  • Use guided forms for structured inputs and separate upload flows for reference assets.
  • Detect invalid file types, oversized files, and incomplete image sets.
  • Preserve original files and show import status rather than pretending reconstruction is complete.

3. Inspect the 3D Model

  • Users open the interactive 3D studio to orbit, isolate, and inspect imported geometry or generated placeholders only when explicitly allowed by the configured service.
  • Use real imported geometry when available and label unsupported geometry clearly.
  • Support component selection, highlighting, hide/show, and camera reset.
  • Fail gracefully when model conversion or texture loading does not succeed.

4. Edit Engineering Context

  • Users review component data, engine assumptions, materials, and revision notes in synchronized side panels.
  • Keep engineering values unit-aware and internally normalized to SI units.
  • Require explicit confirmation before applying changes that affect geometry or key specifications.
  • Show stale indicators when a change invalidates prior analysis or reports.

5. Analyze, Report, and Share

  • Users run calculations, inspect preliminary audit findings, and export reports for stakeholders.
  • Show methodology, input values, and confidence for each calculation or finding.
  • Lock export formats to available conversion services and data completeness.
  • Record comments, approvals, and revision history for traceability.

Advanced and Power-User Features

  • Revision branching with compare-and-restore flows for engine, exterior, chassis, and paint workspaces.
  • Engineering audit classification with confirmed inconsistency, calculated issue, simulation issue, or missing information.
  • Localized interface with translation dictionaries and a framework that can extend to Telugu later.
  • Feature flags for simulation, reconstruction, and advanced optimization modules not yet available in V1.
  • Background job history for file conversion, analysis, and export generation.

Interface and Accessibility Principles

  • Dark industrial theme with strong contrast, compact panels, and minimal decorative effects.
  • 3D viewport prioritized in the center, with project tree, properties, and revision timeline in surrounding panels.
  • Typography optimized for engineering readability, including monospace for values and measurements.
  • Accessible color tokens and keyboard navigation for core project and workspace actions.
  • Fast loading states and optimistic UI only where actions are safe to retry.

Priya starts a new EV concept in AstraForge and uploads a STEP assembly plus a few reference images. Within minutes she has a project record, a visible component hierarchy, and a 3D view she can inspect with her team.

Arjun opens the same project, reviews the engine assumptions, and runs a basic calculation workflow. The system shows what is computed, what is estimated, and what still needs verification, so the team can focus on real gaps instead of guessing.

When the design changes, the revision system marks dependent results stale and preserves the prior outputs. That gives the startup a reliable engineering trail, faster review cycles, and fewer mistakes from disconnected files and spreadsheets.

User-Centric Metrics

  • 80% of new users create or import a project and reach first meaningful value within 10 minutes.
  • At least 60% of active users open a project in the 3D viewer each week.
  • Average time to complete a basic engine specification workflow is under 15 minutes.
  • At least 70% of users who run an audit can identify a recommended next step from the output.
  • Reduce user-reported file import confusion by 50% within 90 days.

Business Metrics

  • Achieve 20% month-over-month growth in activated workspaces for the first two quarters after launch.
  • Reach a 30% trial-to-paid conversion rate for teams with more than 3 users.
  • Maintain 40%+ three-month retention among paid teams.
  • Generate at least 25% of new leads from shared reports and exported project summaries.
  • Secure 2 pilot enterprise accounts within 6 months.

Technical Metrics

  • 99.5% monthly uptime for core project, import, and workspace APIs.
  • P95 API response time under 300 ms for standard project read operations.
  • Background processing success rate above 95% for supported file conversions and report jobs.
  • Zero exposure of secrets or private environment variables to the frontend bundle.

Tracking Plan

  • Track sign_up_completed and sign_in_completed events.
  • Track project_created, project_import_started, and project_import_completed events.
  • Track file_upload_failed with reason codes for invalid format, size limit, and parse error.
  • Track 3d_view_opened, component_selected, and revision_restored events.
  • Track engine_calculation_run and audit_finding_viewed events.
  • Track report_generated and export_completed events.
  • Track language_changed and collaboration_invite_sent events.

Technical Needs

  • Frontend built with Next.js, React, TypeScript, Tailwind CSS, and React Three Fiber.
  • Backend built with FastAPI, SQLAlchemy, PostgreSQL, and Alembic migrations.
  • Background jobs handled by Redis and Celery or an equivalent worker queue.
  • Object storage through an S3-compatible service with a local development adapter.
  • Unit-aware calculation layer with SI units stored internally and presentation conversion on the client or API layer.
  • Localization framework with translation dictionaries and profile-level language persistence.
  • Testing with Pytest, frontend component tests, API integration tests, and end-to-end coverage for core flows.

Integration Points

  • Authentication provider or built-in email/password auth with secure session management.
  • S3-compatible object storage for CAD files, images, exports, and reports.
  • Optional simulation services such as OpenFOAM and CalculiX through backend workers.
  • LLM provider abstraction for the AI assistant with server-side API key handling.
  • Optional analytics and error monitoring such as PostHog and Sentry.

Data Storage & Privacy

  • Store uploaded files, revision history, and audit logs separately with strict access control.
  • Preserve file provenance, original filenames, MIME types, size, checksum, and upload timestamps.
  • Use role-based permissions and organization boundaries for all project data.
  • Support deletion and retention workflows aligned with GDPR and CCPA expectations where applicable.
  • Avoid sending sensitive project files to AI providers unless the user and organization policy explicitly allow it.

Scalability & Performance

  • Use asynchronous job queues for file conversion, imports, calculations, and report generation.
  • Cache read-heavy project summaries and project lists with invalidation on revision changes.
  • Stream large file uploads directly to object storage where possible.
  • Design the database with indexed UUID foreign keys and time-based queries for revisions and activity logs.

Potential Challenges

  • Large CAD files may slow conversion and viewing, so mitigate with background processing, previews, and file size limits.
  • Hindi localization may break technical terms if translated literally, so mitigate with a controlled glossary and reviewable translation keys.
  • Engineering calculations can be misread as validated results, so mitigate with explicit assumptions, confidence labels, and validation status.
  • A single shared data model can become overly coupled, so mitigate with bounded modules and revision-aware interfaces.
  • AI recommendations may encourage unsafe changes, so mitigate with approval workflows and human review requirements for safety-critical actions.

Team & resourcing - Small product team - 2 full-stack engineers, 1 backend/data engineer, 1 product designer, part-time PM, and fractional DevOps support.

Phase 1: Foundation MVP · Weeks 1–4

  • Authentication and organization scaffolding
  • Project dashboard and CRUD
  • English and Hindi localization framework
  • Core database schema and migrations
  • Basic permissions and audit logging
  • Design system and shared navigation

Phase 2: Vehicle Data and 3D Workspace · Weeks 5–8

  • File upload pipeline with validation and storage
  • Project asset metadata model
  • 3D viewer for imported geometry
  • Component hierarchy and inspection panel
  • Import status and error handling
  • Initial report and export stubs tied to real project data

Phase 3: Engineering Workspaces · Weeks 9–12

  • Engine workspace with validated basic calculations
  • Exterior, paint, and parts management workspaces
  • Preliminary AI engineering audit
  • Revision history and stale-result tracking
  • Comment threads and basic collaboration permissions

Phase 4: Intelligence and Release Hardening · Weeks 13–16

  • AI assistant with project-aware context
  • One real tested engineering analysis integration
  • Report generation and supported exports
  • End-to-end tests for the core workflow
  • Monitoring, backup, deployment docs, and release readiness checks

Paste this into Cursor, Bolt, Lovable, or v0 to start building.

Build a production-ready web app called AstraForge, an AI-powered automotive engineering studio for creating, importing, inspecting, and analyzing vehicle projects.

Use Next.js, React, TypeScript, Tailwind CSS, React Three Fiber, and Three.js for the frontend. Use FastAPI, PostgreSQL, SQLAlchemy, Alembic, Redis, and Celery for the backend and background jobs. Use S3-compatible object storage for uploaded CAD files, images, reports, and exports.

Core requirements:
1. Authentication with secure sessions and role-based permissions for view, comment, edit, and admin.
2. Bilingual English and Hindi UI with a localization framework and saved language preference.
3. Dashboard with project creation, search, filter, sort, duplicate, archive, and delete flows.
4. Vehicle project model with UUIDs, project metadata, vehicle category, collaborators, revisions, imported assets, components, analysis results, reports, and permissions.
5. Vehicle creation from structured text inputs and from uploaded reference images.
6. CAD and image import pipeline supporting STEP, IGES, STL, OBJ, GLB/GLTF, DXF, PDF, PNG, JPG, and JPEG with validation, progress, status, and original-file preservation.
7. Interactive 3D vehicle studio with load, rotate, pan, zoom, fit to screen, selection, highlight, hide/show, isolate, camera reset, screenshots, and component hierarchy.
8. Engine workspace with engine specifications, basic physically plausible calculations, RPM torque and horsepower charts, material notes, and revision tracking.
9. Exterior design, paint customization, and parts/assembly workspaces tied to the same shared vehicle data model.
10. Preliminary AI engineering audit with findings that include evidence, severity, confidence, possible cause, recommended action, and validation method.
11. AI assistant that is project-aware, supports English and Hindi, uses tool calling, and requires approval before consequential changes.
12. Revision history with autosave, checkpoints, compare, restore, branches, and stale-result tracking.
13. Reporting and export for project overview, component data, audit results, and supported file exports.
14. Basic collaboration with comments, activity log, and sharing permissions.

Implementation guidance:
Create the repository structure, database schema, API contracts, and shared engineering data model first. Then implement Phase 1 end-to-end with working UI, backend routes, persistence, validation, and tests. Keep the design premium and industrial with dark graphite styling, compact panels, and a large central 3D viewport. Do not fake simulation or CAD results; clearly label unavailable advanced capabilities. Include loading, empty, error, and success states for every workspace.

Business Idea

MASTER BUILD PROMPT AI AUTOMOTIVE ENGINEERING & INNOVATION STUDIO — VERSION 1 1. YOUR ROLE You are the Chief Technology Officer (CTO), Lead Software Architect, Senior Full-Stack Developer, AI Engineer, 3D Engineering Developer, and Product Engineering Lead for this project. Your responsibility is to plan, architect, develop, test, and deliver a functional AI-powered automotive engineering application. Do not behave like a simple website generator. Build a real, scalable software product with working backend services, frontend interfaces, databases, engineering workflows, file processing, AI functionality, and interactive 3D visualization. Think like a CTO responsible for delivering a commercial engineering product. Make technically sound decisions. Explain major architectural decisions. Avoid unnecessary complexity. Do not claim a feature works unless it has been implemented and tested. 2. PRODUCT IDENTITY Product name: AI Automotive Engineering & Innovation Studio Product type: AI-powered automotive design, engineering, analysis, testing, optimization, and collaboration platform. Primary users: - Automotive engineers - Mechanical engineers - Vehicle designers - Engineering students - Automotive startups - Research and development teams - Automotive manufacturers - Independent vehicle developers Supported vehicle categories: - Passenger cars - SUVs - Sports cars - Racing vehicles - Commercial vehicles - Electric vehicles - Hybrid vehicles - Motorcycles - Scooters - Other four-wheel and two-wheel vehicles The platform must support both new vehicle creation and existing vehicle improvement. 3. PRODUCT VISION Build one unified application where users can: 1. Create a new vehicle concept. 2. Import an existing vehicle. 3. Upload CAD files, engineering drawings, documents, and photographs. 4. Reconstruct or visualize an imported vehicle in 3D. 5. Inspect and manage individual vehicle components. 6. Design engines and powertrain concepts. 7. Design vehicle exteriors. 8. Customize paint, colors, finishes, and body styling. 9. Manage chassis, structures, materials, and assemblies. 10. Perform preliminary AI engineering audits. 11. Investigate possible engineering flaws. 12. Perform supported engineering calculations and simulations. 13. Compare competing vehicle technologies. 14. Optimize designs. 15. Maintain engineering revisions and project history. 16. Generate engineering reports. 17. Export and share project information. All workspaces must operate on one shared vehicle project and consistent engineering data model. Never build disconnected demo modules. 4. CTO DEVELOPMENT PRINCIPLES Follow these rules throughout development: - Build a modular monolithic backend initially, with separately deployable simulation workers. - Use clean architecture and reusable components. - Maintain one source of truth for vehicle and component data. - Use stable UUIDs for projects and components. - Preserve original imported files. - Never overwrite original engineering geometry. - Maintain complete revision history. - Use unit-aware engineering calculations. - Use SI units internally. - Support unit conversion for displayed values. - Validate every user input. - Handle failed uploads and simulation jobs safely. - Include loading, empty, error, and success states. - Implement real authentication and authorization. - Use secure file storage. - Keep API keys and secrets on the server. - Never expose private environment variables to the frontend. - Include automated tests. - Document APIs and setup instructions. - Use feature flags for incomplete capabilities. Do not generate the entire application in one uncontrolled code-generation operation. Build and verify one functional module at a time. 5. BILINGUAL APPLICATION The application must support: 1. English 2. Hindi Requirements: - Language selector in application settings. - Language selector accessible from the main navigation. - English as the default language. - Hindi translations for navigation, labels, buttons, menus, notifications, forms, and validation messages. - Language preference saved to the user profile. - Language switching without losing project data or unsaved work. - Unicode-compatible database and frontend. - Support for Hindi text rendering. - AI assistant can understand and respond in English or Hindi. - Engineering terminology should retain standard technical meanings. - Technical units, symbols, formulas, and component identifiers must not be translated incorrectly. Use a translation dictionary and localization framework. Do not hardcode interface text in components. Design the localization architecture so Telugu and additional languages can be added later. 6. USER INTERFACE AND DESIGN SYSTEM Visual direction: Premium industrial CAD software combined with modern engineering software. Theme: Dark graphite, subtle glassmorphism, minimal industrial design. Primary colors: - Graphite: #101820 - Steel: #192833 - Slate: #293A46 - Teal: #00A99D - Champagne: #C4A36A - Silver: #B7C4C9 - White: #E9F0F2 - Error: #D65C62 - Warning: #E0AA54 Typography: - Inter for body and navigation. - Space Grotesk for headings. - JetBrains Mono for engineering figures. Layout: TOP: Project name, current workspace, save status, revision, export, profile, settings. LEFT: Project tree, vehicle hierarchy, components, engineering tools. CENTER: Large interactive 3D viewport. RIGHT: Properties, dimensions, materials, component details, engineering controls. BOTTOM: Revision timeline, simulation status, output logs, selected component information. AI assistant: Collapsible contextual engineering assistant. Design rules: - Prioritize 3D viewport space. - Avoid excessive empty space. - Use compact professional panels. - Use readable technical measurements. - Keep controls aligned. - Avoid excessive gradients and decorative AI elements. - Glass effects must never reduce text readability. - Support desktop and tablet layouts. - Keep mobile layouts usable for monitoring and reviewing projects. 7. MAIN APPLICATION NAVIGATION Create these main workspaces: 1. Dashboard 2. Project Management 3. Vehicle Creation 4. Vehicle Import and Reconstruction 5. 3D Vehicle Studio 6. Engine Engineering 7. Exterior Design Studio 8. Aerodynamics Engineering 9. Chassis and Structural Engineering 10. Paint and Customization Studio 11. Parts and Assembly Engineering 12. AI Engineering Audit 13. Competitive Intelligence 14. Virtual Testing Laboratory 15. AI Optimization and Research 16. Revision and History Manager 17. Engineering Reports and Exports 18. Collaboration and Sharing 19. Settings and Administration Every navigation item must open a functional workspace, not an empty placeholder. If a workspace is planned for a later release, show its availability status honestly. 8. PROJECT MANAGEMENT Implement: - Create project. - Edit project. - Duplicate project. - Archive project. - Delete project with confirmation. - Search projects. - Filter projects. - Sort projects. - Project categories. - Project descriptions. - Project thumbnails. - Project status. - Project creation date. - Last modified date. - Project owner. - Project collaborators. - Project revision. - Project files. Every project must have: - Project UUID. - Vehicle UUID. - Vehicle category. - Project metadata. - Components. - Engineering specifications. - Imported assets. - Revisions. - Analysis results. - Reports. - Permissions. 9. VEHICLE CREATION Provide two creation workflows. A. Create from text: User enters: - Vehicle name. - Vehicle type. - Vehicle category. - Vehicle purpose. - Engine or motor type. - Fuel or energy type. - Target performance. - Design style. - Reference description. - Optional reference images. AI should produce: - Vehicle concept description. - Proposed specifications. - Design directions. - Initial engineering assumptions. - Suggested components. - Concept images where image generation is configured. B. Create from reference: Allow users to upload: - Vehicle photographs. - Sketches. - Reference designs. - Technical drawings. Generate concept proposals based on the provided references. Clearly distinguish concept images from engineering CAD geometry. 10. EXISTING VEHICLE IMPORT Supported formats where appropriate: - STEP / STP - IGES / IGS - STL - OBJ - GLB / GLTF - DXF - PDF - PNG - JPG / JPEG Implement: - Drag-and-drop upload. - Multiple-file upload. - File size and format validation. - Upload progress. - Import status. - Processing status. - Failed import handling. - File metadata. - Original file preservation. - Unit and scale detection where possible. - Geometry validation. - Missing geometry detection. - Duplicate detection. - Component extraction where supported. For photographs: Allow front, rear, side, top, and perspective photographs. Implement a guided image upload workflow and identify missing or poor-quality views. Use an image reconstruction service only where configured. Important: Photographs alone cannot establish exact hidden geometry, material properties, dimensions, or manufacturing tolerances. Allow manual measurement and correction. 11. INTERACTIVE 3D VEHICLE STUDIO Use Three.js and React Three Fiber. Implement: - Load supported 3D models. - Rotate. - Pan. - Zoom. - Fit to screen. - Front view. - Rear view. - Side view. - Top view. - Perspective view. - Component selection. - Component highlighting. - Hide and show components. - Component isolation. - Exploded-view presentation where supported. - Component information panel. - Model visibility controls. - Basic measurement tools where geometry supports them. - Model hierarchy. - Background controls. - Screenshot capture. - Camera reset. Use real geometry from imported assets. Do not substitute unrelated generic 3D vehicle models for uploaded models. For engineering-grade CAD editing, use an appropriate CAD kernel and preserve the source geometry. 12. ENGINE ENGINEERING Create an engine workspace. Engine configurations: - Single-cylinder. - Inline. - V-type. - Flat / boxer. - Rotary. - Multi-cylinder. - Hybrid powertrain. - Electric motor. Inputs: - Engine type. - Fuel type. - Displacement. - Cylinder count. - Bore. - Stroke. - Compression ratio. - Target horsepower. - Target torque. - RPM range. - Cooling type. - Lubrication type. - Intended application. Components: - Engine block. - Cylinder head. - Pistons. - Connecting rods. - Crankshaft. - Camshaft. - Valves. - Fuel injection. - Turbocharger. - Intercooler. - Cooling system. - Lubrication system. - Exhaust system. Implement: - Engine specifications. - Component library. - Engine assembly hierarchy. - Engine concept visualization. - Performance calculations. - RPM versus torque chart. - RPM versus horsepower chart. - Fuel consumption estimates when sufficient inputs exist. - Thermal engineering inputs. - Material selection. - Engineering notes. - Revision tracking. Use physically appropriate equations and input validation. Do not claim target horsepower or torque has been achieved unless supported by a validated calculation, simulation, or test. 13. EXTERIOR DESIGN STUDIO Implement: - Front design. - Rear design. - Side design. - Top design. - Roofline. - Bonnet. - Doors. - Bumpers. - Grille. - Headlights. - Tail lights. - Fenders. - Spoilers. - Diffusers. - Body kits. - Mirrors. - Windows. - Wheel styling. Allow: - Text-based design instructions. - Reference image upload. - AI concept generation. - Before-and-after comparison. - Save design versions. - Restore original design. Separate visual concept generation from editable CAD modification. 14. AERODYNAMICS ENGINEERING Implement an aerodynamics workspace. Inputs: - Vehicle geometry. - Vehicle speed. - Air density. - Ambient conditions. - Reference area. - Airflow boundary conditions. Display where calculated or simulated: - Drag coefficient. - Drag force. - Lift force. - Pressure distribution. - Velocity distribution. - Flow separation. - Airflow paths. - Front airflow. - Underbody airflow. - Rear airflow. Integrate OpenFOAM through a simulation service when configured. Provide simulation setup, job status, results, logs, and comparison. Do not fabricate CFD results. 15. CHASSIS AND STRUCTURAL ENGINEERING Implement: - Chassis type. - Spaceframe. - Monocoque. - Unibody. - Tubular structures. - Suspension mounting locations. - Material assignment. - Dimensions. - Weight estimates. - Structural components. - Load definitions. - Engineering notes. Support future and configured FEA integration through CalculiX or an equivalent solver. Show stress, deformation, and safety-factor results only when produced by an appropriate calculation or simulation. 16. PAINT AND CUSTOMIZATION STUDIO Provide these modes: - Original factory restoration. - Modern redesign. - Futuristic styling. - Personalized styling. - Reference-image-based styling. - Text-based customization. - AI-generated suggestions. Finishes: - Gloss. - Matte. - Satin. - Metallic. - Pearl. - Chrome appearance. - Brushed metal. - Carbon-fiber appearance. - Chameleon. Customization: - Single color. - Dual-tone. - Triple-tone. - Gradients. - Racing stripes. - Graphics. - Liveries. - Camouflage. - Individual body-panel colors. - Wheel colors. - Trim colors. Display color values where available: - HEX. - RGB. - CIELAB. - Finish type. - Roughness. - Reflectance parameters where supported. Implement design locks so that a paint change does not unexpectedly alter vehicle geometry. Keep visual paint properties separate from verified physical coating specifications. 17. PARTS AND ASSEMBLY ENGINEERING Implement: - Component library. - Component identifiers. - Component names. - Component categories. - Component dimensions. - Material assignment. - Weight. - Compatibility information. - Parent-child hierarchy. - Assembly tree. - Component visibility. - Assembly status. - Exploded-view presentation where supported. - Bill of Materials. - Part revision history. - Replacement tracking. Preserve relationships between components and the master vehicle. 18. AI ENGINEERING AUDIT Create an AI-assisted engineering investigation workspace. Inspect available vehicle data for potential problems in: - Engine. - Cooling. - Airflow. - Aerodynamics. - Chassis. - Structural design. - Materials. - Suspension. - Braking. - Exterior packaging. - Component fitment. - Manufacturing. - Serviceability. - Electrical architecture. Each finding must include: - Finding ID. - Component ID. - Problem description. - Supporting evidence. - Severity. - Confidence. - Possible cause. - Recommended action. - Required additional data. - Suggested validation method. Classify findings as: 1. Confirmed data inconsistency. 2. Calculation-detected issue. 3. Simulation-detected issue. 4. Potential engineering risk. 5. Missing information requiring inspection. Never claim an engineering failure is confirmed without adequate evidence. Require human review for safety-critical recommendations. 19. COMPETITIVE INTELLIGENCE Implement a vehicle comparison workspace. Compare: - Vehicle category. - Engine type. - Horsepower. - Torque. - Power-to-weight ratio. - Fuel consumption. - Energy consumption. - Drag coefficient. - Materials. - Dimensions. - Performance. - Price where reliable data is available. Show: - Comparison tables. - Technical gaps. - Potential improvements. - Research references. - Data sources. - Confidence and data completeness. Use sourced information. Clearly mark estimated or unavailable specifications. 20. VIRTUAL TESTING LABORATORY Create a testing dashboard with the following environments. A. Engine testing: - RPM. - Torque. - Horsepower. - Throttle. - Engine load. - Temperature. - Fuel flow. B. Vehicle testing: - Accelerator. - Brake. - Steering. - Clutch. - Gear selection. - Speed. - RPM. C. Environmental testing: - Road conditions. - Temperature. - Rain. - Wet road. - Wind. - Terrain. D. Performance testing: - Acceleration. - Braking. - Handling. - Suspension. - Tire grip. - Thermal performance. E. Reliability and safety: - Thermal conditions. - Structural scenarios. - Component durability. - Failure scenarios. V1 implementation: Build the test configuration, input controls, result management, and at least one validated or clearly labelled simplified calculation workflow. Connect actual simulation engines where available. A visual demonstration must never be presented as validated vehicle physics. 21. AI OPTIMIZATION AND RESEARCH Build a contextual AI engineering assistant. It should: - Understand project context. - Answer engineering questions. - Explain component properties. - Suggest design improvements. - Analyze available simulation outputs. - Identify missing data. - Compare design revisions. - Generate technical reports. - Explain calculations. - Suggest next engineering investigations. Allow instructions such as: "Improve radiator airflow without significantly increasing aerodynamic drag." The AI must: 1. Identify the relevant vehicle components. 2. Check available engineering data. 3. Identify missing inputs. 4. Explain proposed changes. 5. Request approval before changing geometry or specifications. 6. Create a separate design revision. 7. Trigger supported analyses. 8. Compare before and after results. AI must not silently change approved engineering designs. 22. REVISION AND HISTORY MANAGEMENT Implement: - Autosave. - Manual save. - Undo. - Redo. - Revision checkpoints. - Revision comparison. - Restore revision. - Design branches. - Change descriptions. - User attribution. - Timestamp. - Component revision IDs. Use independent revision histories for: - Engine. - Exterior. - Aerodynamics. - Chassis. - Paint. - Assembly. - Simulation. - Optimization. Maintain a master project revision connecting module revisions. When a relevant upstream geometry or parameter changes, mark dependent simulation results as stale. Preserve historical results and their exact input configuration. 23. REPORTS AND EXPORTS Support appropriate export formats: - STEP. - IGES. - STL. - OBJ. - GLB / GLTF. - DXF. - PDF. - CSV. - XLSX. - PNG. - JPEG. Only enable a format when the underlying data and conversion service support it. Report types: - Project overview. - Vehicle specification. - Component specification. - Engineering audit. - Material report. - Simulation report. - Revision comparison. - Bill of Materials. - Design summary. Include assumptions, units, data sources, solver configuration, and validation status. 24. COLLABORATION Implement: - User accounts. - Team workspaces. - Invite collaborators. - View permission. - Comment permission. - Edit permission. - Admin permission. - Project sharing. - Comment threads. - Activity log. - Revision attribution. Prepare the data architecture for live multi-user collaboration. Do not claim real-time simultaneous CAD editing unless it is actually implemented and tested. 25. AI ASSISTANT ARCHITECTURE The AI assistant must operate using structured project context. Provide: - Conversation history. - Project-aware context. - Component-aware context. - Engineering question answering. - File summarization. - Report generation. - Design recommendations. - Function/tool calling. - Approval workflow. Use a provider abstraction so different LLM providers can be integrated. Do not hardcode API keys. Add: - Rate limiting. - Token and cost monitoring. - Error handling. - Request logging with privacy protection. - User approval for consequential actions. 26. TECHNICAL ARCHITECTURE Recommended stack: Frontend: - React. - Next.js. - TypeScript. - Tailwind CSS. - React Three Fiber. - Three.js. Backend: - Python. - FastAPI. - REST APIs. - WebSockets where needed. Database: - PostgreSQL. - SQLAlchemy or equivalent ORM. - Database migrations. Storage: - S3-compatible object storage. - Local development storage adapter. Engineering: - Open CASCADE. - OpenFOAM. - CalculiX or equivalent. - Project Chrono in later integration stages. - Blender for asset preparation. Background processing: - Redis. - Celery or equivalent task queue. Testing: - Pytest. - Frontend component tests. - API integration tests. - End-to-end tests. Deployment: - Docker. - Environment-based configuration. - CI/CD pipeline. - Production logging. - Backups. - Monitoring. Do not force every engineering package into the frontend. CAD conversion and simulations must run through appropriate backend services or workers. 27. DATABASE ENTITIES Create a normalized and maintainable data model containing: - Users. - Organizations. - Teams. - Projects. - Vehicles. - Vehicle components. - Assemblies. - CAD assets. - Imported files. - Materials. - Specifications. - Engineering findings. - Simulation jobs. - Simulation configurations. - Simulation results. - AI conversations. - AI recommendations. - Revisions. - Revision changes. - Reports. - Exports. - Comments. - Permissions. - Audit logs. Use UUIDs, timestamps, relationships, indexes, and appropriate constraints. Preserve file metadata and provenance. 28. SECURITY AND SAFETY Implement: - Secure authentication. - Role-based access control. - Secure file upload. - File type validation. - Upload size limits. - API authorization. - Secret management. - Audit logging. - Backup and restore. - Input validation. - Rate limiting. - Error monitoring. Treat engineering recommendations as advisory until reviewed. Do not provide unsupported claims of roadworthiness, crashworthiness, manufacturing readiness, or regulatory compliance. Require qualified engineering review for safety-critical changes. 29. VERSION 1 DELIVERY SCOPE V1 must prioritize a working end-to-end workflow. REQUIRED V1: 1. User authentication. 2. Bilingual English/Hindi interface. 3. Dashboard. 4. Project creation and management. 5. Vehicle creation from structured inputs. 6. CAD and image import. 7. Interactive 3D viewer. 8. Component hierarchy. 9. Component inspection. 10. Engine specifications and basic calculations. 11. Exterior design workspace. 12. Paint customization. 13. Parts and assembly management. 14. Preliminary AI engineering audit. 15. AI assistant. 16. Revision history. 17. Engineering reports. 18. Supported file exports. 19. Basic collaboration and permissions. 20. At least one real, tested engineering analysis integration. V1 ADVANCED OR STAGED INTEGRATIONS: - Full parametric CAD editing. - Advanced photogrammetry reconstruction. - Full vehicle-wide CFD. - Advanced conjugate heat transfer. - Validated crash simulation. - Advanced structural optimization. - Full vehicle dynamics simulation. - Real-time multi-user CAD editing. - Manufacturing-ready automated design generation. Show unavailable advanced capabilities honestly and provide integration points for future releases. 30. DEVELOPMENT ROADMAP PHASE 1 — FOUNDATION: - Repository setup. - Database. - Authentication. - Localization. - Dashboard. - Project management. - Shared design system. PHASE 2 — VEHICLE DATA AND 3D: - File upload. - CAD processing. - 3D viewer. - Component hierarchy. - Model metadata. PHASE 3 — DESIGN WORKSPACES: - Engine. - Exterior. - Paint. - Parts. - Assembly. PHASE 4 — ENGINEERING INTELLIGENCE: - AI assistant. - Preliminary engineering audit. - Recommendations. - Engineering calculations. - Reports. PHASE 5 — SIMULATION: - Simulation job system. - First CFD integration. - Results viewer. - Validation workflow. PHASE 6 — PROFESSIONAL RELEASE: - Permissions. - Collaboration. - Exports. - Revision comparisons. - Automated testing. - Deployment. - Documentation. 31. DEFINITION OF DONE A module is complete only when: - Its UI exists. - Its backend functionality exists. - Its database integration works. - Its validation works. - Its error states work. - Its permissions work. - Its tests pass. - Its documentation is available. A button must perform its advertised action. A chart must use real calculated, imported, or simulated data. A simulation result must identify its inputs and method. A file export must produce a valid file. A revision restore must actually restore the appropriate data. A language switch must translate the actual interface. A project must persist after logout and login. 32. HOW YOU MUST START Do not generate the entire application immediately. First: 1. Inspect the existing repository. 2. Identify existing code and dependencies. 3. Propose the architecture. 4. Create the folder structure. 5. Define the database schema. 6. Define the API contracts. 7. Define the shared engineering data model. 8. Create the implementation roadmap. 9. Identify external dependencies and licensing considerations. 10. Identify technical risks. Then begin Phase 1. Create working code, not just documentation. After each implementation phase: - Run the application. - Run relevant tests. - Fix errors. - Update documentation. - Report completed functionality. - Report remaining functionality. - Identify blockers. - Recommend the next implementation task. Do not rewrite working modules unnecessarily. Do not introduce mock data into production workflows. Mock data is allowed only in clearly identified demo or testing environments. 33. REQUIRED FIRST RESPONSE FROM THE CTO AGENT Before coding, return: A. Product architecture. B. Recommended repository structure. C. Database entity relationships. D. Frontend and backend architecture. E. Engineering service architecture. F. V1 feature prioritization. G. Development milestones. H. Key technical risks. I. Required dependencies. J. Initial implementation tasks. Then start Phase 1 after presenting the plan. FINAL PRODUCT STANDARD The goal is to build a real AI-powered automotive engineering application. It must connect vehicle design, CAD geometry, component management, engineering analysis, AI assistance, simulation, optimization, revision management, and collaboration into one coherent platform. Prioritize correctness, working functionality, engineering traceability, performance, maintainability, and user experience. Do not sacrifice engineering reliability for visual appearance. Build a product that can grow into a professional automotive engineering platform.

Make My PRD

Design by The Resonance | Powered by GPC – The AI Transformation Company

    PRD: MASTER BUILD PROMPT AI AUTOMOTIVE ENGINEERING &...