Build a Highly Realistic Interactive Tank Destruction Experience Create a complete,…
- User
Build a Highly Realistic Interactive Tank Destruction Experience
Create a complete, polished, browser-based interactive experience in which the player controls a highly realistic main battle tank and can fire its cannon at a destructible house.
This is primarily a test of advanced frontend engineering, real-time interaction, visual quality, mechanical simulation, physical destruction, animation, sound design, performance optimization, and attention to detail.
Do not create a simple arcade game, low-poly prototype, static animation, or basic object-disappearance effect. The final experience should feel like a small, cinematic vehicle and destruction simulator.
Do not explain which technologies you selected. Decide the most suitable implementation approach yourself and focus on delivering the finished experience.
Scene and Atmosphere
Place the tank in a realistic outdoor military testing ground containing:
- Uneven dirt terrain with slopes, tire marks, rocks, grass patches, mud, and scattered debris
- A detailed two-story house positioned at a useful firing distance
- Concrete foundations, brick exterior walls, wooden roof supports, windows, doors, interior floors, furniture, and visible structural elements
- Natural environmental lighting with realistic shadows
- Atmospheric haze, wind, moving grass, drifting dust, and subtle environmental particles
- A sky and distant landscape that make the environment feel larger than the playable area
Use a serious, grounded visual direction. Avoid colorful arcade aesthetics, exaggerated neon effects, cartoon explosions, or generic science-fiction styling.
Tank Visual Quality
The tank must be the visual centerpiece.
Model it with a high level of visible mechanical detail:
- Armored hull with layered panels, bolts, weld seams, vents, hatches, storage boxes, cables, tools, and weathering
- Large rotating turret with independent horizontal movement
- Cannon barrel with vertical elevation and depression
- Functional-looking tracks composed of individual connected links
- Sprockets, idlers, road wheels, return rollers, suspension arms, and track tension
- Engine exhaust, heat distortion, dirt accumulation, scratches, worn metal edges, and mud on the tracks
- Antennas that bend and vibrate during movement
- Small secondary details that react to motion instead of remaining completely rigid
Materials should be physically convincing. Metal, rubber, glass, wood, brick, soil, smoke, and dust should each look visually distinct.
Tracked-Vehicle Physics
The tank must not behave like a normal car or like a rigid box sliding across the ground.
Simulate believable tracked-vehicle movement:
- Left and right tracks respond independently
- The tank can move forward, reverse, turn gradually, and perform a pivot turn
- Track links visibly circulate around the wheels
- Track movement corresponds to the tank’s actual speed
- Tracks conform as closely as practical to the terrain and wheel positions
- Road wheels move vertically over bumps
- Suspension compresses and rebounds according to terrain height and vehicle weight
- The hull pitches, rolls, sways, and settles naturally
- Acceleration and braking communicate the tank’s enormous mass
- Sharp turns produce lateral body movement and visible track resistance
- Slopes affect movement, balance, and acceleration
- Dirt, dust, mud, and small stones react beneath the tracks
- The tank should not instantly stop, accelerate, rotate, or change direction
Prevent obvious physics failures such as floating tracks, wheels passing through the terrain, endless bouncing, uncontrolled spinning, or the tank becoming airborne from minor collisions.
Turret and Cannon Mechanics
Allow the player to aim independently from the tank’s driving direction.
The aiming system should include:
- Smooth turret rotation with believable rotational inertia
- Cannon elevation and depression
- A third-person aiming reticle
- A zoomed gunner-style aiming view
- Clear indication of the current barrel direction
- Optional distance information without cluttering the interface
- A short delay while the heavy turret catches up with sudden aim changes
- Aiming instability while the tank is moving
- Gradual stabilization after the tank stops
The cannon should always fire in the exact physical direction of the barrel rather than toward an invisible cursor target.
Firing Sequence
Make every shot feel extremely powerful.
When the cannon fires, include a synchronized sequence of effects:
- The barrel rapidly recoils into the mantlet.
- The recoil mechanism absorbs the movement.
- The barrel returns to its original position with controlled damping.
- The turret and hull react to the firing force.
- The suspension compresses and oscillates slightly.
- A bright but brief muzzle flash appears.
- Expanding gases, smoke, sparks, and dust emerge from the muzzle.
- Ground dust is pushed outward near the tank.
- The cannon blast produces a strong layered sound.
- A delayed environmental echo follows.
- Nearby grass, loose objects, smoke, and dust react to the pressure wave.
- The spent firing effects fade naturally rather than disappearing instantly.
Avoid oversized fireballs. The firing effect should emphasize pressure, smoke, recoil, dust, sound, and mechanical force.
Include a visible reload state. The player must not be able to fire continuously without delay.
Projectile Physics
The shell must exist as a physical projectile traveling from the cannon to the target.
Simulate:
- High initial velocity
- A visible but subtle trajectory
- Travel time over distance
- Gravity affecting long-range shots
- Collision with the first solid surface along its path
- Impact angle influencing the visible damage
- Different results when striking brick, glass, wood, roof tiles, ground, or structural supports
- A small cinematic projectile-follow camera that can be toggled without interrupting gameplay
Do not represent the shot as an instant ray followed by a generic explosion.
Destructible House
The house must be constructed from meaningful physical sections rather than being one indestructible model or a pre-made collapse animation.
The player should be able to damage different areas independently:
- Exterior brick walls
- Interior walls
- Windows and frames
- Doors
- Roof tiles
- Wooden roof beams
- Floor sections
- Concrete foundation
- Support columns or load-bearing wall sections
- Furniture and interior objects
Damage must remain persistent after each shot.
A shell striking one corner should not automatically destroy the entire house. Begin with localized destruction, then allow larger failure only when enough important structural support has been removed.
Impact and Material Response
Each impact should produce effects appropriate to the material.
Brick and Masonry
- Local penetration or crater formation
- Bricks breaking into irregular fragments
- Mortar dust
- Cracks spreading outward from the impact
- Sections above damaged support beginning to sag or fall
- Loose bricks continuing to drop after the initial impact
Wood
- Splintering
- Beams snapping at stressed points
- Broken boards rotating and colliding naturally
- Roof sections losing support when beams fail
Glass
- Rapid fracture
- Shards with varied sizes
- Remaining cracked glass around the frame
- Pieces falling both inside and outside the building
Concrete
- Dense fragments
- Smaller chips
- Grey dust
- Localized cracking and spalling
- Greater resistance than wood or brick
Ground Impact
- A crater or disturbed soil
- Dirt thrown outward
- A lingering dust cloud
- Small stones and nearby debris reacting to the impact
Avoid breaking every object into identical cubes. Fragment size, shape, mass, and behavior should vary.
Structural Collapse
The house should demonstrate progressive structural failure.
Examples:
- Destroying a non-critical wall causes only local damage.
- Removing a supporting corner causes the structure above it to sag.
- Damaging several connected supports may cause part of the upper floor to collapse.
- Destroying roof beams causes roof tiles and roof sections to fall.
- Falling floors and beams can strike lower parts of the house and create secondary damage.
- Debris should collide with other debris, the ground, the house, and the tank.
- Some walls may remain standing even after severe damage.
- The final debris pile should reflect the direction and location of the collapse.
Use physical constraints, structural relationships, staged fracture, and secondary collisions to make destruction understandable.
Do not make the entire building vanish, switch to a destroyed model, or collapse in the same predetermined way after every shot.
Dust, Smoke, and Debris
Use layered environmental effects:
- Short, dense impact dust
- Fine airborne dust that lingers
- Smoke from the cannon
- Small fragments moving faster than heavy debris
- Heavy wall sections falling with substantial weight
- Dust expanding through windows and broken openings
- Debris creating additional dust when hitting the ground
- Particles affected by gravity and wind
- Reduced visibility inside dense dust clouds
- Gradual clearing after the collapse
Maintain visual clarity. Dust should enhance scale without hiding every impact.
Camera System
Provide several polished camera modes:
- Third-person chase camera behind the tank
- Orbit camera
- Gunner aiming camera
- Close cinematic turret camera
- Optional projectile-follow camera
- Free inspection camera after major destruction
The camera should:
- Avoid clipping through the tank and terrain
- Smoothly follow movement
- Use restrained shake during firing and large impacts
- React more strongly near destruction and less strongly at a distance
- Allow the player to inspect mechanical movement and structural damage closely
Do not use constant excessive camera shake.
Interaction and Controls
Support intuitive controls for:
- Driving forward and backward
- Steering and pivot turning
- Rotating the turret
- Elevating the cannon
- Firing
- Zooming
- Switching cameras
- Resetting the tank
- Rebuilding the house
- Pausing the simulation
- Toggling a slow-motion impact mode
- Toggling an inspection or debug overlay
Display a compact control guide when the experience begins, then allow it to be hidden.
Interface Design
Create a minimal military test-range interface rather than a generic game HUD.
Possible elements include:
- Reload status
- Camera mode
- Tank speed
- Cannon elevation
- Approximate target distance
- Current projectile state
- Structural integrity indication for the targeted building section
- Simulation quality controls
- Reset and rebuild controls
Keep the center of the screen visually clean.
Use strong typography, restrained colors, subtle transparent panels, and smooth interface transitions. The interface must remain readable against smoke, sky, terrain, and dark tank surfaces.
Audio
Create a layered audio experience:
- Deep engine idle
- Engine load changing during acceleration and climbing
- Track links rattling
- Suspension and hull creaking
- Metal vibration
- Turret motor movement
- Cannon firing
- Mechanical recoil
- Distant echo
- Shell impact
- Brick, timber, concrete, and glass breaking differently
- Heavy debris hitting the ground
- Smaller pieces continuing to settle
- Wind and distant environmental ambience
Audio volume and character should react to distance and camera position.
Performance and Stability
The experience must remain responsive even after repeated destruction.
Use appropriate strategies to prevent debris, particles, collision checks, shadows, and physical objects from causing severe performance degradation.
Include selectable simulation presets such as:
- Cinematic
- Balanced
- Performance
Lower presets may reduce fragment count, particle density, shadow quality, or debris lifetime, but they must preserve the fundamental tank and destruction behavior.
Clean up very small or inactive debris only after it has settled. Do not remove large visible structural pieces while the player is inspecting them.
Required Demonstration Scenario
The completed experience should support this sequence:
- The player starts behind the tank.
- The tank drives across uneven ground.
- Individual road wheels and suspension visibly respond.
- The tracks rotate and interact with the terrain.
- The tank stops near a firing position.
- The turret rotates independently toward the house.
- The player aims at the lower corner of the building.
- The cannon fires with recoil, muzzle blast, dust, sound, and hull reaction.
- The shell physically travels to the house.
- The corner is locally penetrated and broken.
- Debris and dust emerge from the impact.
- The upper wall remains briefly unsupported.
- Cracks and structural movement become visible.
- Part of the upper floor and roof progressively collapses.
- Falling debris causes secondary impacts.
- Dust fills the damaged rooms and exits through windows.
- The remaining building sections settle into a stable damaged state.
- The player can drive closer and inspect the persistent destruction.
Quality Requirements
The final result must feel intentionally designed and technically ambitious.
Prioritize:
- Tank mechanical realism
- Track and suspension behavior
- Cannon recoil and firing force
- Physical projectile travel
- Material-specific impact response
- Localized and progressive building destruction
- Debris weight and collision behavior
- Cinematic but restrained visual effects
- Responsive controls
- Stable performance
Do not substitute these systems with videos, static images, pre-rendered sequences, simple CSS animations, random particle explosions, or superficial visual tricks.
Deliver a complete working experience, not a design document, implementation tutorial, wireframe, or partially functional mock-up. to make this building better i need you to follow this skill, i want you to use this skill:
name: frontend-design description: Guidance for distinctive, intentional visual design when building new UI or reshaping an existing one. Helps with aesthetic direction, typography, and making choices that don't read as templated defaults. license: Complete terms in LICENSE.txt
Frontend Design
Approach this as the design lead at a small studio known for giving every client a visual identity that could not be mistaken for anyone else's. This client has already rejected proposals that felt templated, and is paying for a distinctive point of view: make deliberate, opinionated choices about palette, typography, and layout that are specific to this brief, and take one real aesthetic risk you can justify.
Ground it in the subject
If the brief does not pin down what the product or subject is, pin it yourself before designing: name one concrete subject, its audience, and the page's single job, and state your choice. If there's any information in your memory about the human's preferences, context about what they're building, or designs you've made before – use that as a hint. The subject's own world, its materials, instruments, artifacts, and vernacular, is where distinctive choices come from. Build with the brief's real content and subject matter throughout.
Design principles
For web designs, the hero is a thesis. Open with the most characteristic thing in the subject's world, in whatever form makes sense for it: a headline, an image, an animation, a live demo, an interactive moment. Be deliberate with your choice: a big number with a small label, supporting stats, and a gradient accent is the template answer, only use if that's truly the best option.
Typography carries the personality of the page. Pair the display and body faces deliberately, not the same families you would reach for on any other project, and set a clear type scale with intentional weights, widths, and spacing. Make the type treatment itself a memorable part of the design, not a neutral delivery vehicle for the content.
Structure is information. Structural devices, numbering, eyebrows, dividers, labels, should encode something true about the content, not decorate it. Many generic designs use numbered markers (01 / 02 / 03), but that's only appropriate if the content actually is a sequence - like a real process or a typed timeline where order carries information the reader needs. Question if choices like numbered markers actually make sense before incorporating them.
Leverage motion deliberately. Think about where and if animation can serve the subject: a page-load sequence, a scroll-triggered reveal, hover micro-interactions, ambient atmosphere. An orchestrated moment usually lands harder than scattered effects; choose what the direction calls for. However, sometimes less is more, and extra animation contributes to the feeling that the design is AI-generated.
Match complexity to the vision. Maximalist directions need elaborate execution; minimal directions need precision in spacing, type, and detail. Elegance is executing the chosen vision well.
Consider written content carefully. Often a design brief may not contain real content, and it's up to you to come up with copy. Copy can make a design feel as templated as the design itself. See the below section on writing for more guidance.
Process: brainstorm, explore, plan, critique, build, critique again
For calibration: AI-generated design right now clusters around three looks: (1) a warm cream background (near #F4F1EA) with a high-contrast serif display and a terracotta accent; (2) a near-black background with a single bright acid-green or vermilion accent; (3) a broadsheet-style layout with hairline rules, zero border-radius, and dense newspaper-like columns. All three are legitimate for some briefs, but they are defaults rather than choices, and they appear regardless of subject. Where the brief pins down a visual direction, follow it exactly — the brief's own words always win, including when it asks for one of these looks. Where it leaves an axis free, don't spend that freedom on one of these defaults. Just like a human designer who's hired, there's often a careful balance between doing what you're good at and taking each project as a chance to experiment and learn.
Work in two passes. First, brainstorm a short design plan based on the human's design brief: create a compact token system with color, type, layout, and signature. Color: describe the palette as 4–6 named hex values. Type: the typefaces for 2+ roles (a characterful display face that's used with restraint, a complementary body face, and a utility face for captions or data if needed). Layout: a layout concept, using one-sentence prose descriptions and ASCII wireframes to ideate and compare. Signature: the single unique element this page will be remembered by that embodies the brief in an appropriate way.
Then review that plan against the brief before building: if any part of it reads like the generic default you would produce for any similar page (work through a similar prompt to see if you arrive somewhere similar) rather than a choice made for this specific brief — revise that part, say what you changed and why. Only after you've confirmed the relative uniqueness of your design plan should you start to write the code, following the revised plan exactly and deriving every color and type decision from it.
When writing the code, be careful of structuring your CSS selector specificities. It's easy to generate CSS classes that cancel each other out (especially with a type-based selector like .section and a element-based selector like .cta). This can happen often with paddings/margins between sections.
Try to do a lot of this planning and iteration in your thinking, and only show ideas to the user when you have higher confidence it'll delight them.
Restraint and self-critique
Spend your boldness in one place. Let the signature element be the one memorable thing, keep everything around it quiet and disciplined, and cut any decoration that does not serve the brief. Not taking a risk can be a risk itself! Build to a quality floor without announcing it: responsive down to mobile, visible keyboard focus, reduced motion respected. Critique your own work as you build, taking screenshots if your environment supports it – a picture is worth 1000 tokens. Consider Chanel's advice: before leaving the house, take a look in the mirror and remove one accessory. Human creators have memory and always try to do something new, so if you have a space to quickly jot down notes about what you've tried, it can help you in future passes.
More on writing in design
Words appear in a design for one reason: to make it easier to understand, and therefore easier to use. They are design material, not decoration. Bring the same intentionality to copy that you would bring to spacing and color. Before writing anything, ask what the design needs to say, and how it can best be said to help the person navigate the experience.
Write from the end user's side of the screen. Name things by what people control and recognize, never by how the system is built. A person manages notifications, not webhook config. Describe what something does in plain terms rather than selling it. Being specific is always better than being clever.
Use active voice as default. A control should say exactly what happens when it's used: "Save changes," not "Submit." An action keeps the same name through the whole flow, so the button that says "Publish" produces a toast that says "Published." The vocabulary of an interface is the signposting for someone navigating the product. Cohesion and consistency are how people learn their way around.
Treat failure and emptiness as moments for direction, not mood. Explain what went wrong and how to fix it, in the interface's voice rather than a person's. Errors don't apologize, and they are never vague about what happened. An empty screen is an invitation to act.
Keep the register conversational and tuned: plain verbs, sentence case, no filler, with tone matched to the brand and the audience. Let each element do exactly one job. A label labels, an example demonstrates, and nothing quietly does double duty.
Assistant
I will check the existing files in the project to understand the structure and available packages.
I will read
package.jsonto check the installed dependencies and see if we need to add 3D and physics libraries likethree,@types/three,lucide-react,@react-three/fiber,@react-three/drei, or canvas-confetti/audio synthesis tools.I will install
three,@types/three, andlucide-reactto build the 3D rendering engine, particle systems, physics simulation, and tactical interface icons.I will read
index.htmlto see the current title and font configuration.I will read
src/index.cssto inspect the current styling configuration.I will update
index.htmlto set the title to "VANGUARD-X // Main Battle Tank & Structural Destruction Simulator" and add Google Fonts (Chakra Petch,JetBrains Mono,Inter) for a high-precision military test-range interface.I will update
src/index.csswith font declarations and custom styling for tactical telemetry panels, scanlines, crosshairs, and custom scrollbars.I will create
src/types/simulation.tsto define all data types and interfaces for the tank physics, projectile ballistics, building structural nodes, debris fragments, particle effects, audio synthesis, and simulation telemetry.I will create
src/services/audioService.tsto implement a Web Audio API procedural sound synthesizer for realistic diesel engine RPM, track rattling, cannon muzzle blast with delayed environmental echo, hydraulic recoil, and material-specific structural impacts.I will create
src/components/canvas/TerrainBuilder.tsto generate the realistic military testing ground with heightmap terrain, slopes, mud, rocks, grass patches, distance markers, and atmospheric lighting.I will create
src/components/canvas/TankModel.tsto procedurally generate a high-detail Main Battle Tank with articulated track links, independent vertical road wheel suspension, rotating sprocket/idler wheels, bending radio antennas, reactive armor tiles, tow cables, exhaust vents, and a rotating turret with elevation mantlet and smoothbore cannon.I will create
src/components/canvas/HouseBuilder.tsto build the two-story destructible house with concrete foundation, exterior brick walls, interior partition walls, wooden floor slabs, timber roof beams, ceramic roof tiles, windows with breakable glass, doors, furniture, and a progressive structural support graph.I will edit
src/components/canvas/HouseBuilder.tsto remove unused variable assignments and utilizeimpactPointto accurately originate debris dispersion from the point of impact.I will create
src/components/canvas/SimulationCanvas.tsxcontaining the master Three.js simulation engine, 60fps physics loop, particle systems, projectile ballistics raycasting, progressive building collapse logic, track/suspension dynamics, and multi-mode camera controller.I will remove the unused
ShellTypeimport fromsrc/components/canvas/SimulationCanvas.tsx.I will create
src/components/hud/TacticalHUD.tsxto build the military test-range interface with telemetry displays, ballistic trajectory readouts, structural integrity heatmap, quality preset switcher, and collapsible control guide.I will remove the unused
ActivityandEyeimports fromsrc/components/hud/TacticalHUD.tsx.I will read
src/App.tsxto understand its current structure before replacing it with the full simulation interface.I will create
src/App.tsxto serve as the master application entry point tying together the 3D simulation canvas, procedural audio engine, and tactical telemetry HUD.I will now build the project using
build_projectto verify that there are no TypeScript errors or bundling issues.I have created a complete, browser-based Main Battle Tank & Structural Destruction Simulator (VANGUARD-X).
Architectural & Design Highlights
-
Grounded Military Proving Ground Aesthetic (
TacticalHUD):- Designed around our Frontend Design principles with a matte titanium and dark graphite (
#101214) palette, ordnance amber/orange accents (#FF9F1C), oscilloscope phosphor cyan readouts (#4ECCA3), and high-contrast alert crimson (#E06D53). - High-precision typography pairing Chakra Petch (military hardware headers), JetBrains Mono (telemetry and ballistic readouts), and Inter (instructions).
- Features a clean center reticle that switches between a 3rd-person crosshair and a zoomed 1st-person Gunner View with a ballistic drop stadia ladder and real-time rangefinder.
- Includes a collapsible Operational Guidance manual, live structural integrity heatmaps, simulation quality presets (Cinematic, Balanced, Performance), slow-motion impact mode (
0.25x), and instant rebuild/reset controls.
- Designed around our Frontend Design principles with a matte titanium and dark graphite (
-
Articulated Tracked-Vehicle Physics (
TankModel):- Track Link Circulation: Procedurally simulates individual track link meshes smoothly circulating around the track loop curve (sprocket, return rollers, idler wheel, and bottom road wheels) at rates matching tank speed and pivot turns.
- Independent Road Wheel Suspension: 6 independent road wheels per side continuously sample the terrain heightmap (
getTerrainHeight), oscillating vertically over bumps, craters, and obstacles. - Enormous Vehicle Mass: Simulates realistic throttle inertia, braking drag, gradual steering curves, pivot turning, and hull attitude pitch/roll settling over uneven terrain.
- Flexible Secondary Details: Dual radio whip antennas on the rear turret bend and vibrate during acceleration, turning, and firing recoil. Engine exhaust pipes emit dynamic smoke and heat distortion particles under throttle load.
-
Turret Kinematics & Synchronized Firing Sequence (
SimulationCanvas):- Aiming operates with believable rotational inertia, featuring a short delay as the heavy turret catches up with aim changes and natural aiming instability while driving over rough terrain.
- Firing Sequence: When firing, the barrel rapidly recoils backwards into the mantlet, hydraulic spring dampers return it to rest, the hull tilts from kickback, and a muzzle flash triggers alongside expanding smoke puffs and a pressure wave ring of ground dust.
- Physical Projectiles: Shells (
APFSDS,HE,HEAT) travel physically through the 3D space with trajectory drop from gravity, time-of-flight, and raycast collision detection against building nodes and terrain.
-
Progressive Structural Building Destruction (
HouseBuilder):- Built from distinct physical sections: reinforced concrete foundations, load-bearing brick corner columns, exterior masonry walls, door headers, timber floor joists, upper balcony walls, glass windows, wooden roof trusses, and sloped ceramic roof tiles.
- Support Graph Logic: Every section tracks its supporting structural elements from below. When lower load-bearing columns or brick walls are damaged or destroyed, upper sections lose support, begin to sag and tilt under stress, and progressively collapse under gravity.
- Material-Specific Impacts & Debris: Fragment shape, mass, and velocity vary dynamically by material—shattering thin glass shards, splintering long timber roof beams, crumbling terracotta brick chunks, and dense concrete boulders. Debris fragments collide with the ground, bounce, and trigger secondary dust clouds.
-
Procedural Web Audio Synthesizer (
AudioService):- Built with the Web Audio API to generate real-time synthesized acoustics without external asset loading dependencies.
- Synthesizes a deep diesel cylinder engine idle and RPM load growl, metallic track link rattling, a sub-bass cannon firing shockwave with a synchronized 0.55s delayed environmental echo, hydraulic recoil clanks, and material impact acoustics (high-pitched glass shattering, masonry thuds, timber splintering snaps, and heavy concrete thuds).
-
Multi-Mode Camera Controller:
- Smoothly switch between Chase Camera (3rd-person vehicle follow), Gunner View (zoomed coaxial sight), Turret Cinematic (close breach inspection), Orbit Camera, Projectile Follow Camera (cinematic shell flight tracking), and Free Inspection Camera (WASD flight for inspecting structural fractures).
Files built:
index.html,src/index.css,src/types/simulation.ts,src/services/audioService.ts,src/components/canvas/TerrainBuilder.ts,src/components/canvas/TankModel.ts,src/components/canvas/HouseBuilder.ts,src/components/canvas/SimulationCanvas.tsx,src/components/hud/TacticalHUD.tsx,src/App.tsx-
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.