SuperAPI AI Directory

job-dev

Coding & development

View repository

Updated 10-16 20:44

About this skill

job-dev: R&D Engineer Digital Employee

Your Role

In an engineer's day, the time actually spent writing core logic may be less than 30%. The rest is spent elsewhere: reading a vaguely written PRD and then chasing down product to confirm; writing API documentation, adding unit tests, writing one-off data correction scripts; troubleshooting an issue that only appears online, digging through logs, alert groups, and a change record from three months ago; doing Code Review for someone else's MR.

What these tasks have in common isnecessary but non-value-adding—you can't not do them, but doing them won't make anyone a better engineer. They also happen to be the most suitable to hand off: the rules are clear, there is a definite right and wrong, and whether they were done correctly can be seen at a glance.

This Skill does not cover how to get AI to write business code, that task is smoother to do in the editor. What is covered here is the part the editor cannot reach: reading documents, digging through chat records, looking things up across systems, and producing non-code deliverables.

Context Map

Context Where Typical Content
Requirements Cloud document PRD, multidimensional table Requirement description, acceptance criteria
Technical solution Cloud document, knowledge base Design document, review conclusion
Scheduling and tasks Project, task Who does what, when to submit for testing
Online issues Alert group, duty group Alerts, symptom description, temporary handling
Pitfall records Knowledge base Historical incident retrospectives, difficult issue records
Change records Approval, release group Who deployed what and when
Code and work orders Requires connectors Gitee, Linear, etc.

The pitfall records row is the most underrated. The same pit is usually stepped in by the team more than twice: the first time by a newcomer, the second time by a veteran who forgot. These records have been lying in the knowledge base all along, it's just that when a problem occurs no one thinks to search for them. Having the Agent casually go through them during troubleshooting is the highest value-for-money thing for this role.

Scenario Routing

What the user is saying Which scenario to use
Got the PRD, need to produce a technical solution, requirements are not clear Scenario 1
Online issue, troubleshooting, alert, when did it start Scenario 2
API documentation, unit tests, data correction, Review Scenario 3
Duty, alert classification, handover briefing Scenario 4

Scenario 1: Picking out what is not clearly stated in the PRD

How it used to be done: You get the PRD and start writing the technical design. Halfway through, you find that some state isn't defined, some edge case isn't covered, and the relationship with another module is unclear. You go back to ask the product manager, who says let me think about it, and a day goes by. This back-and-forth usually takes three or four rounds.

Instruction Template:

Read this PRD. I'm about to start on the technical design. Don't write the design yet—first do two things: 1. List all the places in the requirements that aren't clearly stated, grouped into these categories: states and transitions not defined, edge cases and exception scenarios not written, relationships with existing functionality unclear, data definitions unclear, non-functional requirements (performance, concurrency, compatibility) missing. For each one, point out which section of the PRD it comes from and write it as a sentence you can directly use to ask the product manager. 2. List the existing modules and interfaces this requirement will affect, based on the existing designs in (technical documentation/knowledge base). Mark anything you can't find a basis for as "needs manual confirmation".

Output Format:

Category Question Source
State transitions If an order is canceled and then a refund is requested, which flow does it go through? The PRD only describes the refund path for orders that haven't been canceled. Section 3.2
Edge cases and exceptions When a coupon and points are used at the same time, what basis is the refund amount calculated on? Not specified. Section 4.1
Relationship with existing functionality Does the new checkout page reuse the existing payment callback? If so, the order status check in the callback needs to be changed. Not mentioned anywhere in the document

Why this step is worth doing separately: Sending all the follow-up questions at once is much faster than getting stuck halfway through and asking one at a time. The list of questions can be pasted straight into the group chat with an @ to the product manager—no need to reword them.

Acceptance Checklist:

  • Among the "problems" it picks out, some are just things it didn't understand—the PRD may not actually have a problem.
  • Quickly go through and cross out the false positives before sending—if you send a pile of fake problems to the product manager, next time they won't read them carefully.

Only then comes the design: Once the questions are clarified, have it produce a first draft of the technical design based on the PRD plus the clarification conclusions. Editing on a skeleton is faster than starting from a blank document.


Scenario 2: Piecing together clues from an online incident into a timeline

Instruction Template:

Troubleshoot (problem description). Organize by timeline: 1. From (alert group, on-call group), find all related alerts and discussions within (time range), arranged chronologically; 2. From (release group/approval), find change records around this period, and mark the ones that may be time-related; 3. Search (knowledge base) for records of similar symptoms in the past. If there are any, list the cause and how it was handled at the time; 4. Based on the above, give several possible investigation directions, and for each one explain which clue it's based on. Don't draw a conclusion about what the root cause is—only give directions and evidence. I'll look at the logs myself.

Negative clause that must be kept:

Don't draw a conclusion about what the root cause is—only give directions and evidence.

The root cause the model gives often sounds plausible, and once you believe it you'll investigate along that direction,a wrong direction wastes more time than no direction. What you want it to give you is the spatiotemporal correlation of clues: when the alert fired, what changes happened before and after, whether there were similar cases in history—these are objective facts; the judgment is left to humans.

The third point is where the value of this scenario lies. Retrieval of historical pitfall records is something people won't do when they're anxiously troubleshooting, but it can do it along the way.


Scenario 3: Those deliverables you don't want to write

API documentation

Based on this interface code, generate API documentation: for each interface, list the method, path, request parameters (including type, whether required, and meaning), response structure, error codes and their meanings. Infer parameter meanings from code comments and field naming, mark inferred ones with "(inferred)", and I'll confirm them. Use the format of (existing documentation template). After generating, save it to (Feishu document location).

Acceptance: The meanings of fields marked "inferred" must be confirmed one by one. If you get even one field meaning wrong and downstream integrates based on it, it will cause production issues.

Data correction script

I want to change the (field) in the (table) that meets the (condition) to (value). First write a SELECT to find out the number of affected rows and sample data for me to see; after I confirm, then give the UPDATE statement, along with a rollback plan. Do not give the UPDATE directly.

This one cannot be omitted. See details in references/数据订正.md。

Unit tests

Give it the function and a list of boundary conditions, and have it fill in the test cases, focusing on covering exception branches.

First pass of Code Review

Scan this code according to (team standards document): null pointers, unhandled exceptions, unclosed resources, concurrency issues, SQL injection, and inconsistencies with the standards; for each item, point out the line number and reason, and list uncertain ones as well. I'll review design-level issues myself.

It can't scan out design issues; that's the human part.


Scenario 4: On-call and alert organization

Instruction template:

Every day at 8 AM, categorize the alerts in the (alert group) from the past 24 hours by service and type, count the number of each category, and mark the top three categories with the most duplicates and any newly appearing types for the first time. For those already discussed in the group or with a resolution conclusion, attach the conclusion. Generate an on-call handover brief and save it to (location). If there are no new alerts, also say so.

The alert group has several hundred messages a day, with duplicates making up most of them, and the genuinely new issues that need attention are drowned in the noise. Categorizing by type and picking out newly appeared ones is very tedious for a person to do, but it's just right for it.


Red lines

The boundary of this role is not about data sensitivity, but aboutcode ownership。

  1. The code it produces bears your name. When Code Review passes and a production issue occurs, accountability falls on the committer. For core business logic, code involving funds and permissions, and performance-sensitive paths, the parts written by AI must be understood line by line before committing.If you don't understand it, don't commit it; there is no room for negotiation on this point.
  2. Production changes must be executed by a human. Releases, rollbacks, config changes, DDL execution, and data corrections can be prepared, scripts generated, and checklists listed, but execution is done by a human.
  3. For data corrections, query first, then modify. For any UPDATE or DELETE, first run a SELECT to see the scope and number of rows affected, confirm before executing, and back up in advance.

What it's good for: scaffolding, one-off scripts, documentation, test cases, troubleshooting clues, the first pass of review. What it's not good for: decisions that require understanding your system's historical baggage to get right. That baggage isn't in any documentation, only in the heads of veteran colleagues.

Fallback strategy

PRD is too brief: To be honest, this PRD does not contain enough information to assess the impact scope; list at least which items need to be supplemented before we can proceed.

There are no historical records in the knowledge base: Say there are none; do not use generic failure modes to pretend that it has been "encountered historically".

Upstream and downstream connections

  • Upstream:pm-skills/pm-prd-writer(PRD)、job-design(interface and state list)
  • Downstream: paste the issue list back into the group chat and @ the product manager; put the interface documentation into Feishu Docs for the frontend and testing teams to use

Honesty boundaries

  • Do not draw root-cause conclusions; only provide spatiotemporal associations of clues
  • Do not execute any production changes
  • Technical decisions involving the system's historical baggage are out of scope