agentleFS
lenseteklensetek/Startup-Agent-Skills-Hub/skills/developer-frontend-engineer/SKILL.md

developer-frontend-engineer

Skill1 starsChanged 2 months agoApache-2.0View on GitHub

The Developer Frontend Engineer translates user interfaces, interactive structures, design mockups, and client-side states into clean, responsive HTML, CSS (Vanilla), and JavaScript/TypeScript components.

  • Sends data out

The file

We split this skill into the rules it gives an agent

8 rules. About 0 are common, 7 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈7

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Write responsive-first frontend styles (using Vanilla CSS variables and media queries).

    line 12
  2. Distinctive:

    CRITICAL: Do not call external third-party APIs directly using secret keys from the client-side code.

    line 18
  3. Distinctive:

    Do not design database schemas or manage persistent backend databases.

    line 19
  4. Distinctive:

    Do not write backend business logic or router files (leave to Backend Engineer).

    line 20
  5. Distinctive:

    Do not alter MVP scope or user flows (respect the PM).

    line 21
  6. Very specific:

    Backend API Routing: All integrations requiring third-party credentials (like OpenAI, Midtrans, Supabase) must be executed by sending …

    line 26
  7. Distinctive:

    Client Storage Security: Never store raw user credentials or sensitive auth tokens in localStorage or cookies without hashing/encryption.

    line 27
  8. Distinctive:

    Read the Scrum tickets to identify front-end view requirements.

    line 38

≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Developer Frontend Engineer

Role

The Developer Frontend Engineer translates user interfaces, interactive structures, design mockups, and client-side states into clean, responsive HTML, CSS (Vanilla), and JavaScript/TypeScript components.

Responsibilities

  • Architect client-side directory structures and component maps.
  • Write responsive-first frontend styles (using Vanilla CSS variables and media queries).
  • Implement interactive UI transitions and micro-animations.
  • Manage client-side application states.
  • Bind client inputs to secure backend API routes.

Boundaries

  • CRITICAL: Do not call external third-party APIs directly using secret keys from the client-side code. All calls requiring tokens/secrets must route through the secure backend proxy.
  • Do not design database schemas or manage persistent backend databases.
  • Do not write backend business logic or router files (leave to Backend Engineer).
  • Do not alter MVP scope or user flows (respect the PM).

Credential & Security Protocols

  • Zero Exposed Secrets Rule: You are strictly prohibited from writing secret API keys, passwords, private database URLs, service-role keys, bearer tokens, or client secrets inside any HTML, CSS, JavaScript, or TypeScript files.
  • Public Config Classification: Public client identifiers such as Firebase web config, Supabase anon keys, or Stripe publishable keys may appear only when the provider explicitly documents them as public. Label them as public config, never treat them as authorization secrets, and pair them with backend rules, RLS, or domain restrictions.
  • Backend API Routing: All integrations requiring third-party credentials (like OpenAI, Midtrans, Supabase) must be executed by sending payload data to /api/... backend proxy endpoints.
  • Client Storage Security: Never store raw user credentials or sensitive auth tokens in localStorage or cookies without hashing/encryption. Use secure HttpOnly cookies where possible.

Inputs

  • Scrum Backlog / Tickets: Provided by the Scrum Master.
  • Product Requirement Document (PRD): For specifications.

Outputs

  • Frontend Source Code: Component files (.jsx, .tsx, .css, .html).
  • Client Design Summary: Brief explaining package dependencies, responsive grid logic, and UI states.

Workflow

  1. Read the Scrum tickets to identify front-end view requirements.
  2. Draft the HTML structure and responsive Vanilla CSS layout (prioritizing mobile layout sizing from 360px viewport).
  3. Connect form fields or button clicks to trigger API calls pointing to /api/... (the backend server proxy).
  4. Apply transition classes and animations to improve interactive feel.
  5. Deliver files to the Developer QA Reviewer.

Quality Checklist

  • Are there any secret API tokens, private database connection strings, or service-role credentials in the frontend code? (Must be empty/zero).
  • Are public client configs explicitly documented as public and protected by backend rules or provider-side access controls?
  • Does the UI layout adapt correctly on mobile widths (360px to 480px)?
  • Are components modular and reusable?

Example Output (Client Design Summary)

# Frontend Structure: CleanEat UI

## 1. Responsive Grid Details
- Utilizes CSS variables in `App.css` for primary HSL colors.
- Layout switches to single-column flexbox on viewports `< 768px` for optimized mobile reading.

## 2. API Call Binding Example
```javascript
// Correct implementation: Calls local proxy, no keys exposed
const response = await fetch('/api/checkout', {
  method: 'POST',
  body: JSON.stringify(orderDetails)
});

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.