Palgu's agent applies these built-in standards and skills to governed work, from product discovery, jobs to be done and specs with acceptance criteria (PDLC) to delivery, testing, review and release (SDLC). Your organization can turn each one off, keep it as guidance or make it required, and add its own.
90 standards and skills
Use standalone components and the Angular CLI conventions for file naming and structure.
Target Java 17+ (21 LTS): records, sealed types, switch patterns; return Optional or empty collections, never null.
Model with val, data classes and sealed interfaces; prefer immutable collections.
Validate input with Form Requests; keep controllers thin and move logic into services or actions.
Use the App Router conventions: server components by default, "use client" only where interactivity needs it.
Use ES modules and async/await; never block the event loop with sync I/O in request paths.
Follow Nuxt directory conventions (pages, components, composables, server) and auto-imports.
Target PHP 8.2+: declare(strict_types=1), typed properties, parameters and return types.
Target Python 3.12+ with type hints on all public functions; keep mypy clean.
Prefer server-rendered HTML with Turbo Drive/Frames/Streams before adding client-side JavaScript.
Use function components and hooks; keep components small and focused on one job.
Follow Rails conventions: RESTful resources, thin controllers, logic in models or plain service objects.
Use Svelte 5 runes ($state, $derived, $effect) for reactivity; keep $effect for side effects only.
Keep strict mode on; do not use any — use unknown and narrow it.
Use the Composition API with <script setup>; keep components single-purpose.
Record every material architecture decision as an ADR: context, the forces at play, options considered, the decision, consequences and trade-offs.
Pick a pattern from the problem's forces, not fashion: style (modular monolith first), boundaries, messaging, data, API, deployment, frontend and AI-agent pa…
Explain a system with several views, never one diagram: context, containers, components, a runtime scenario, data/state and deployment (C4 levels plus arc42…
Make module, layer and bounded-context boundaries explicit and state the allowed dependency directions.
Before changing an existing system, build an as-built baseline: repo inventory, build, module map, runtime and dependency topology, data, interfaces, auth, t…
Choose the migration strategy from current and target state: strangler fig, branch by abstraction, parallel change, shadow/differential runs, canary ramp. Bi…
Turn each relevant quality attribute (latency, throughput, availability, security, privacy, cost, accessibility, maintainability) into a measurable scenario:…
Layer controller → service → repository; controllers only map HTTP. Constructor injection, never @Autowired fields.
Methods and references for architecture intelligence from the Palgu framework registry, with what each is for.
Methods and references for technical due diligence from the Palgu framework registry, with what each is for.
Give agents and tools least privilege: scoped credentials, allowlisted actions, bounded budgets, and reversible or approved side effects.
Review every change that crosses a trust boundary for injection, broken access control, SSRF, deserialization, XSS and unsafe file handling (ASVS as the refe…
Resolve dependencies from lockfiles under the project's integrity policy; review new or bumped dependencies for maintenance, licence and known vulnerabilities.
Model threats at a depth proportional to risk: trust boundaries, assets, abuse cases and mitigations (STRIDE or similar).
Methods and references for security, privacy & supply chain from the Palgu framework registry, with what each is for.
Target WCAG 2.2 AA unless the manifest says otherwise.
Ship AI features with an eval suite for the task: quality, grounding, safety and robustness, with thresholds declared before the change.
Review a diff through distinct lenses, each with its own search: intent, correctness and edge cases, data and transactions, concurrency, API compatibility, t…
Unit tests are not proof. Before calling a change done, exercise the real code path end to end: a live request, a CLI session, the running app, a migration o…
Set budgets per route and journey: LCP <= 2.5s, INP <= 200ms and CLS <= 0.1 at p75 for user-facing web, plus API p95/p99 latency targets.
Write the failing spec first. Use request specs for endpoints and model specs for domain rules; system specs only for key journeys.
Write the failing test first from the acceptance criteria, watch it fail for the right reason, then write the minimum code; for a bug, reproduce it in a test…
Capture use-case intent for meaningful behaviour: actor, trigger, goal, constraints, success and failure meaning.
Anything with a UI, dashboard or CLI surface gets visual proof: screenshots or terminal captures of the actual rendered result, attached to the PR.
Methods and references for testing & verification from the Palgu framework registry, with what each is for.
Tell users what the AI can and cannot do, mark AI-generated content, and show uncertainty where it matters.
Start from the design manifest: product archetype, audience, brand levers and forbidden tropes; ask for what is missing.
Express repeated decisions as semantic tokens (colour, type, spacing, radius, elevation) and reuse accessible primitives before building custom ones.
Load Tailwind v4 via @tailwindcss/postcss and add @source for shared UI packages; keep focus logical after client navigation.
Load Tailwind v4 via @tailwindcss/vite and add @source for shared layers; add the NuxtRouteAnnouncer component and keep focus logical after navigation.
Build: Tailwind v4 tokens in @theme named by role; whole static class names; Radix or React Aria for dialogs, menus, comboboxes.
Build: Tailwind v4 tokens in @theme named by role; whole static class names; Bits UI or Melt UI for dialogs, menus, comboboxes.
Identify the UI archetype and the user's primary job first; let hierarchy follow job importance.
Build: Tailwind v4 tokens in @theme named by role; whole static class names; Reka UI or Headless UI for dialogs, menus, comboboxes.
Labels, visible focus, landmarks and keyboard flow for every interactive screen, checked with real evidence.
Define semantic design tokens first, then style every control through them so themes, contrast and brand stay consistent.
Build web UI from the product's archetype, tokens and states; the look is chosen per brief, never a stock aesthetic.
Let the schema enforce critical domain invariants: keys, foreign keys, NOT NULL, CHECK and unique constraints; denormalize only on purpose.
Name events for the domain occurrence, in the past tense, with a stable noun vocabulary (`project_created`, not `button_clicked`).
Methods and references for migration & modernization from the Palgu framework registry, with what each is for.
Attribute spend to meaningful scopes (service, feature, tenant) with tags so cost can be reasoned about.
Env: keep secrets in `wrangler secret`; vars in wrangler.toml are public config.
Env: set secrets with `fly secrets set`; never bake them into the image.
Env: set secrets in site environment variables scoped per deploy context.
Env: store secrets as service variables; use reference variables for shared ones.
Env: use an environment group for secrets; never commit .env files.
Env: keep secrets in `vercel env` per environment, never in the repo or NEXT_PUBLIC_ vars.
Choose channels that fit the product (organic search, AI answers, marketplaces, email, social, referral, partners) and instrument each entry surface.
Before production, make failure detectable in the affected paths: structured logs, metrics, traces and service identity (OpenTelemetry).
Instrument the product's success loop: acquisition, activation, engagement, retention, revenue, each with a formula and an owner.
Never deploy to production yourself: no `--prod` CLI call, release script, push or merge to an auto-deploying branch, workflow dispatch, or apply against a p…
Promote the exact artifact that passed pre-production; know the staging/production config deltas.
Methods and references for reliability, delivery & operations from the Palgu framework registry, with what each is for.
Eligibility first: pages must be crawlable and indexable by the engines you want citations from; no invented AI-only markup.
Public pages return 2xx over HTTPS, are allowed by robots.txt, have intentional canonicals, and are listed in a sitemap; noindex only on purpose.
Classify the app first (public content, SaaS, directory, API, AI app, commerce, mobile, internal tool, marketplace, library) and derive what "complete" means…
List the riskiest assumptions across value, usability, feasibility and viability, and test the riskiest first with the cheapest credible method.
Before a commit or PR that changes behaviour, validate it functionally (exercise the real code path) and, for any UI, visually; attach the proof to the PR.
Select frameworks from the project archetype, stack, industry, jurisdiction and risk tier, not all of them every time.
Pick the review mode from risk: R0 quick, R1 standard, R2 high, R3 critical, plus baseline, security, migration, dependency, hotfix and AI-generated change r…
A human understands a change when they can predict it: purpose, context, responsibilities, runtime and failure behaviour, state, interfaces, rationale, quali…
Frame features as the job a user hires the product for: actor, situation, motivation, desired outcome.
Plan the launch: audience, exposure path, guardrail metrics, support readiness, comms and rollback.
The PDLC is a continuous loop, not a stage gate: sense, frame, explore, de-risk, shape, deliver, release, validate outcome, learn.
Keep this layout; create what is missing, never overwrite a file.
Keep README, SECURITY.md and CODEOWNERS accurate; protect default and release branches; require PRs and checks for material changes.
A gate is a question answered with evidence. For each stage, use the check atoms that fit the project and record the evidence each relies on.
Know which stage the work is in and what question it must answer: S0 problem, S0A existing-system recon, S1 discovery, S2 definition, S3 requirements, S4 UX,…
Before work enters delivery, shape it into a product readiness contract: objective, users, problem, evidence, solution thesis, risks, success metrics, accept…
Decompose outcome -> deliverable -> story -> task; stop when a task is atomic, testable and fits a timebox.
Build the diagnostic program from the decision it serves (acquisition, investment, rescue, scale-up) and the product's jobs, not a fixed checklist.
Methods and references for industry overlay from the Palgu framework registry, with what each is for.
Methods and references for planning & task design from the Palgu framework registry, with what each is for.
Methods and references for product semantics from the Palgu framework registry, with what each is for.
Methods and references for repository engineering from the Palgu framework registry, with what each is for.