anmh1205/angent-engineer-fallback

Manually invoked interview-driven technical advice that pressure-tests an idea, issue, spec, plan or design one focused question at a time before returning confirmed requirements, recommendation and trade-offs.

Automate browser, web-app and browser-shell desktop flows through the active browser/computer-use capability, with observable state and session safety.

Turn an existing codebase capability into an agent-friendly CLI and/or MCP surface with stable contracts, credentials, docs, tests and packaging.

Route a multi-step or ambiguous engineering request to the smallest useful combination of Engineer Skills and Agents.

Generate or edit branded imagery using a real image backend, with explicit native Nano Banana prompt-pack mode and honest provider/asset limits.

Safely analyze/generate image, video, audio and documents using available host modalities or exact-pinned Multix when installed, preserving backend limits and source evidence.

Reason safely about the real AgentKit product control plane when the user specifically asks to inspect, configure, install, recover or remove AgentKit-managed state.

Deliver an explicitly requested architecture advisory with bounded alternatives, trade-offs, YAGNI, and decision gates without implementing.

Route bounded measurable iteration to the installed workflow that actually owns optimization, prediction, scenario expansion or security review.

Design and implement a bounded production backend, API or data-access change while preserving the current stack, external contracts, state ownership, security, migration boundaries and operational evidence.

Plan and implement a Better Auth integration in an existing JavaScript/TypeScript application while keeping credentials, schema changes, sessions, provider scope and production rollout explicit.

Bootstrap a new project from an accepted product contract through evidence-grounded stack/design decisions, planning, implementation, testing, review and onboarding.

Turn incomplete delivery intent into an accepted outcome contract and compare materially different approaches before planning or implementation.

Restate the immediately previous assistant message in plainer, shorter language without changing its meaning, evidence strength, warnings, decisions, or authority.

Use an authorized real Chrome profile when the active browser runtime supports it; otherwise fall back to an isolated session without extracting credentials.

Review pending changes, commits, pull requests or codebase scope independently against requirements, system behavior, edge cases and fresh verification evidence.

Guide a long-running goal with a verifiable stop condition; use Codex goal-mode features when available and portable Continuity semantics otherwise.

Set an explicit 0–5 explanation/style preference while calibrating technical depth to the user's domain and respecting runtime persistence limits.

Diagnose context pressure, memory boundaries and degradation using measured host signals, scoped retrieval, compaction and behavioral evaluation.

Implement a clear task or accepted plan through inspect → change → verify → review, preserving scope, authority and evidence across interactive, autonomous and parallel modes.

Write conversion-oriented marketing and product copy from audience, offer, evidence and desired action while preserving or extracting the intended writing style.

Conduct authorized defensive CTI and OSINT investigations through AEAD case lifecycle, documented collection gaps and source-backed intelligence reporting.

Design and change PostgreSQL/MongoDB data models, queries, indexes and migrations with workload evidence, least-privilege access, rollout compatibility and explicit production recovery gates.

Diagnose software failures by proving the causal root cause before changing code, then verify the original symptom and relevant blast radius with fresh evidence.

Evaluate an external coding model on DeepSWE through a verified Pier/OpenRouter benchmark harness with cost and reproducibility gates.

Detect the project's actual deployment target and perform an explicitly authorized deployment with environment, artifact, migration, health and rollback verification.

Design brand identities, logos, campaign graphics, posters, banners, social assets, icons and visual presentation systems from authentic brand evidence and production-aware visual principles.

Prepare and verify containers, CI/CD, Kubernetes, cloud and GitOps changes through explicit plan/apply, environment, deployment and deletion gates.

Compile or render reviewable system/editorial diagrams from typed structure, Mermaid, or prepared HTML using the capabilities actually available in the active harness.

Initialize, update, summarize or audit project docs and root agent context from current evidence without imposing a universal file layout.

Discover current versioned library/framework/API documentation from canonical sources, llms.txt indexes and installed package evidence.

Route Word, PDF, PowerPoint and spreadsheet tasks to real native format skills/tools with source fidelity, editable structure and rendered quality gates.

Review an existing site or app for both human UX quality and AI/search discoverability, produce ranked fixes with a DONE contract, and optionally implement and verify them when authorized.

Author editable Excalidraw architectural diagrams with real MCP canvas or file-based scene JSON, grounded source relations, export and visual verification.

Build a grounded explanation or mental model of a concept, code path, system, failure, or decision in Markdown by default, with optional simplified wording or self-contained HTML when supported.

Apply proportional evidence-led reasoning, adversarial tests and mechanically verifiable output constraints without invented evidence or internal-reasoning disclosure.

Route to installed AgentKit/ANGENT capabilities or discover trustworthy external skills through real ecosystem tools with explicit install approval.

Repair a concrete software failure from bounded intent through scout, root-cause diagnosis, cause-aligned implementation, regression/side-effect verification and review.

Create minimal subfolder AGENTS.md instructions only when durable subtree-specific constraints merit their cost.

Turn an approved brief, screenshot or video reference into a distinctive implementation-ready or working frontend interface with explicit aesthetic direction, complete states, accessibility and rendered visual verification.

Implement React/TypeScript frontend behavior using the project's actual component, routing, data, state and styling contracts with complete UI states and browser-aware verification.

Perform disciplined Git commit, push, PR, merge, merge-PR and stacked-PR operations without hiding unrelated work, secrets or unsafe history rewrites.

Operate GitHub issues, pull requests, Actions, Projects and repository/org administration through the strongest available GitHub provider capability with live-state evidence.

Use a verified GitLab Knowledge Graph index for definition, reference and impact queries, with explicit limitations and source-backed fallback search.

Prepare a long-running autonomous goal by locking outcome, constraints, evidence, authority and execution readiness before the run starts.

Design, implement, evaluate and deploy version-verified Google ADK Python agents, workflows, MCP/A2A tools and correct state/artifact lifecycles.

Construct and query provenance-aware knowledge graphs from code/documents/media using a verified Graphify installation or a bounded portable replacement.

Create a portable, redacted continuation artifact that lets a successor agent resume in-progress work safely across sessions, models, or harnesses.

Explain available ANGENT fallback capabilities and point native AgentKit users to the official AgentKit help/documentation surfaces.

Build and render HTML-first HeyGen HyperFrames video compositions with pinned-CLI timing contracts, preview/lint and optional authorized cloud rendering.

Elicit user-owned project vision and structured decisions through incremental, evidence-preserving document updates.

Convert an issue into a validated implementation plan by reading the issue, scouting the codebase, resolving design uncertainty and producing auditable phases.

Select, investigate and preserve meaningful chronological engineering evidence as a technical journal, without confusing it with active work state or general memory.

Generate curated llms.txt and optional llms-full.txt from authoritative documentation, respecting the llmstxt.org format, links, source scope and user-approved output path.

Run an authorized bounded optimization loop using a numerical metric, immutable guard, noise-aware measurement and isolated reversible experiments.

Read long Markdown and plan directories through a trusted localhost browser reader with outline, Mermaid and safe file/server boundaries.

Build workflow-oriented, typed, least-privilege MCP servers and verify them in a real client with realistic agent tool-use evaluations.

Convert and inspect audio/video/images with FFmpeg, ImageMagick and optional RMBG, preserving originals, deterministic batch behavior and format-aware QA.

Author Mermaid v11 diagrams, validate them for their actual target renderer, and render or integrate accessible SVG/PNG/PDF where supported.

Author or maintain a Mintlify docs site with version-verified docs.json, MDX, navigation, API references, AI assets and local validation/deployment checks.

Design, implement and verify iOS/Android apps in React Native, Flutter, Swift/SwiftUI or Kotlin/Compose with explicit platform selection, lifecycle, offline sync, permissions, performance and store-release boundaries.

Coordinate staged or parallel jobs across available agent runtimes/workers with explicit dependencies, isolation, capture and independent synthesis.

Build, extend, or operate a project-specific reusable page-composition system using the project's existing stack, components, storage, preview, and publication boundaries.

Integrate SePay/VietQR, Polar, Stripe or another selected payment provider using explicit business/provider state machines, idempotency, authenticated webhooks, reconciliation and lifecycle verification.

Produce a durable implementation roadmap from an accepted outcome, with evidence-grounded phases, dependencies, risks, validation gates and explicit unresolved decisions.

Open a verified AgentKit integrated plans dashboard when installed; otherwise present an evidence-labelled read-only plan board without claiming native dashboard parity.

Pre-analyze risky changes through five separated expert lenses, reconcile worst-case conflicts and issue a GO/CAUTION/STOP advisory verdict with optional reason/probe follow-up.

Inspect existing files or create Markdown/HTML visual explanations, diagrams, slide decks, diffs, plan reviews and recaps with verified rendering.

Apply targeted, source-grounded problem reframing methods to complexity spirals, innovation blocks, recurring patterns, bad assumptions and scale uncertainty.

Reconcile durable multi-phase plans with optional live task tracking, verify completion, update all affected phases and coordinate meaningful docs/status changes.

Route artifacts to project-owned paths and safely plan explicit restructures without imposing a universal folder layout.

Audit or improve React/Next.js performance using an explicit baseline, installed-version compatibility, ranked evidence, bounded mutation and comparable before/after verification.

Create and validate React/Remotion programmatic videos with frame-exact timeline, asset lifecycle and real render evidence.

Package bounded local/remote repositories for model context or audit using verified Repomix, with source, secret, format and token-budget checks.

Conduct decision-focused technical research with current authoritative evidence, explicit source/support boundaries, conflict reconciliation and actionable implications.

Author a standalone decision-ready research assignment, not research findings, with source and uncertainty requirements.

Generate source-grounded engineering retrospectives with defined Git time windows, reproducible metrics, contextual delivery evidence and optional period/team comparisons.

Review one or more pull requests end to end; optionally repair, publish a formal review, or merge only after explicit authority and fresh readiness evidence.

Generate evidence-grounded edge cases and test targets across the stable twelve dimensions, with one-shot or bounded novelty/saturation exploration.

Map the files, symbols, tests, configuration and relationships relevant to a bounded codebase question using read-only local evidence and optional explicitly permitted delegation/external probes.

Run a bounded defensive security workflow covering secrets, dependencies, source patterns, STRIDE/OWASP threat reasoning, optional red-team discovery and authorized fix-and-reverify work.

Author and debug GLSL/WebGL fragment shaders with correct coordinates, SDF/noise math, version-specific compilation and GPU visual/performance checks.

Move a completed branch through repository delivery gates to an authorized push/PR/merge endpoint, with official/beta/dry-run modes and optional explicitly gated publication side effects.

Build Shopify apps, extensions and themes against current Shopify APIs/CLI with explicit surface selection, scopes, API versions, webhook lifecycle, development-store testing and deployment/publish gates.

Build preference-aware bilingual or single-language HTML showcases with proof-led narrative, responsive visuals, optional verified screenshot capture and explicitly authorized publication.

Create, update, audit or optimize portable agent Skills with precise discovery, progressive disclosure, safety/portability boundaries and behavioral validation.

Turn recent verified implementation evidence and related issues into a concise product-impact judgment and up to three measurable next steps.

Use real Google Stitch project/quota and design export workflows where authorized, or clearly degrade to a source-grounded frontend-design replacement.

Provide a requested post-implementation handoff recap grounded in actual artifacts, test evidence, delivery status and unresolved risks.

Build with the installed TanStack Start, Router, Form and AI packages using current package-specific server/client, validation, streaming and security contracts.

Coordinate live teammate sessions with shared work, direct communication, ownership, verification and cleanup when the active runtime exposes a real team lifecycle.

Produce source-grounded, publish-ready SVG/PNG technical diagrams with explicit semantics, coherent visual style, deterministic validation and rendered visual review.

Validate software behavior, create missing test protection, audit deceptive or ineffective tests, and optimize suite/CI cost without weakening evidence or project-defined gates.

Build and verify real Three.js/WebGL/WebGPU scene graphs, assets and animation using version-matched APIs and renderer performance evidence.

Implement or refine component-level React UI styling with the project's actual tokens/primitives, responsive behavior, interaction states and accessibility, including safe shadcn/Tailwind adaptation when present.

Build or review a product UI decision system across hierarchy, layout, typography, color, interaction, accessibility, responsive behavior, forms/charts and performance; preserve approved rules and verify implementation.

Orchestrate scoped issue-to-PR development with optional explicitly authorized beta/stable shipping, advisory gates and post-merge CI convergence.

Summarize in-flight work from Git branches/worktrees, plans and roadmaps, prioritizing safe next steps with truthful scanner and remote-ref limitations.

Build, migrate and review Next.js or Turborepo projects using the installed versions, explicit render/cache/build contracts, SEO/GEO surfaces and bounded package/deployment effects.

Design and run repeatable web unit, component, integration, API/contract, E2E, visual, accessibility, performance/load and browser-compatibility tests with explicit environment/data boundaries.

Expose existing web-page features as bounded in-browser WebMCP tools with explicit schemas, effect annotations, origin controls, authorization and live-surface verification.

Create, inspect, audit and safely clean isolated Git worktrees for parallel/risky work, including exact branch names, base selection, monorepos and submodules.

Extract, compare and plan a source-repository feature adaptation with explicit source/destination contracts, challenge gates and authorized implementation handoff.