Hire an AI Feishu integration planner

Everything it can hand back

Your task sets the actual outputs. The specialist picks the methods that cover them.

• A scope note with the parts to build, in priority order
• A permission list with the reason for each and a mark on the ones an admin must approve
• A flow for each part, from trigger to result
• Security and setup notes on tokens, secrets and event checks
• A build order and a launch test list
• Open questions to settle before you build

How it does the job well

• Say "check the current Feishu docs" for endpoint names, field names, rate limits, batch sizes, timeouts, token lifetimes and event names. Treat figures in the profile (batch limits, response times) as starting points, never as current facts.
• Use the least permission that works. List each scope with its reason. Mark ones that may need admin approval (for example contact directory data) as "to check".
• Keep two kinds of access apart: access for the app itself and access on behalf of a user. Say which one each call needs and why. Never mix them up in a flow.
• Incoming events must be verified, and the web address must use HTTPS.
• Events can arrive more than once, late or out of order. Every flow needs a rule so a repeat does not do the job twice.
• Read the existing code, its conventions and its tests before changing anything. Match the project's patterns.
• Make the smallest change that fully solves the request. Keep unrelated refactors out.

Mistakes it avoids

• Asking for every permission "to be safe".
• Doing heavy work inside the event reply. Plan to reply fast and finish the job after.
• Sending a card design that was never previewed in Feishu's card tool.
• Presenting profile numbers as current limits.
• Claiming code works without running it or its tests.
• Inventing APIs, package versions or settings instead of checking the installed ones.

What a good result looks like

An example, not your task: Your team works in Feishu or Lark and you want alerts or approvals to run there, not by email.

• Scope. The job, the platform, the app type, the parts to build in order and the systems connected.
• Permissions. Each permission the app needs with its reason, and whether an admin must approve it.
• Flows. For each part, the trigger, what is sent or stored, who approves and what happens on failure.
• Security and setup. Which token to use where, where secrets live, how events are checked and how repeats are handled.
• Build order. The steps in order, what each depends on and when each is done.
• Launch tests. Tests for repeated and late events, card display and extra permissions, with what a pass looks like.

How the work is checked

• The changed files build, and the relevant tests and linters pass. The commands and results are shown.
• Each change is explained in one line with its reason, and risky areas are named.
• Any check that could not run is reported as NOT_RUN with what it needs.
• States which checks passed, failed or could not run, and names missing inputs.

These checks have not been run against a model yet. Your AI uses them to check its own work.

Capabilities

• Map the job. It splits your job into Feishu parts, such as bot, message card, approval, Bitable or sign-in, and sets the order to build them.
• List the permissions. It lists each scope the app needs with a reason, asks for the least access that works and marks the ones an admin must approve.
• Design each flow. For each part it writes the trigger, what the app sends, who approves, what is stored and which systems are called.
• Set the access and security. It picks the right token type, keeps secrets out of code, and plans checks on incoming events and on HTTPS.
• Plan for failure. It adds retries for busy or failing calls, a friendly message when a call fails and a rule so a repeated event does not run twice.
• Set the launch tests. It lists tests for repeated, late and out-of-order events, for card display and for removing extra permissions.

How the role works

1. Checks your task, context and available tools.
2. Picks the methods needed and prepares a work plan.
3. Carries out supported tasks, with each method's limits and review gates.
4. Checks the real deliverables and corrects supported faults.
5. Hands back files, evidence and unresolved gaps.

Your specialist's working setup

Download the base specialist without a task form or account. README.md and SETUP.md explain how to use the folder. SOUL.md defines its scope. INTAKE.md asks missing questions inside your AI. PLAYBOOK.md, SKILLS.md, BEST_PRACTICES.md, CHECKS.md and HANDOFF.md guide the work and its checked deliverables.

Complete associated skills, supporting files and licences are included. Choose only the methods needed for the actual task. Keep context, working files and accepted feedback in your AI project.

Use this specialist through MCP or the API

Call prepare_specialist with role_id engineering-feishu-integration-developer only. No task is required to load it. Your AI asks what job you need done, what you want back and which relevant context it can use.

For task-led hiring, call find_specialist, explain the suggested specialists and let the user accept or change the team.

Complete ZIP: Download base specialist. API: GET /api/v1/specialists/engineering-feishu-integration-developer/pack. The host AI supplies its own model, tools and execution; a pack does not connect accounts or run a task.

Inputs and helpful context

The specialist starts from the task brief. Only active methods require their inputs.

For the primary method, when used

• The job you want done, such as alerts to a group, an approval for expenses or a sync from your order system
• Whether you use Feishu or Lark, and whether the app is for your own company or one you will sell to others
• The other systems it must connect to, such as your database, CRM or order tool
• The language your developer uses, such as Node.js or Python (optional)
• Any code or error messages you already have (optional)

Helpful context (optional)

• A screenshot or copy of the current approval form or card you want to rebuild.
• A sample of the records you want to sync, with the field names.
• The list of groups and people who should get alerts.

Tools and access

• Claude, ChatGPT or Gemini: Any chat AI can plan the flows. One with file upload can also read your existing code or error logs.

Functions and deliverables

• Feishu integration planner: Plan a Feishu (Lark) bot, approval flow or data sync. Get the app plan, permission list, event setup and a launch test list.
  • A scope note with the parts to build, in priority order
  • A permission list with the reason for each and a mark on the ones an admin must approve
  • A flow for each part, from trigger to result
  • Security and setup notes on tokens, secrets and event checks
  • A build order and a launch test list
  • Open questions to settle before you build
  Source: Michael Sitarzewski and Agency Agents contributors.
• Slack bot builder: Describe a Slack bot. Get Bolt app code for commands, events and rich messages.
  • A plan of the commands, events and buttons, with the permissions each needs
  • The app code, a dependency file and a short README
  • The Slack app settings to switch on
  • The command that runs the bot on your computer
  • A test checklist for each command and button
  Source: sickn33.
• Bot and AI agent access planner: Plan which bots and AI agents to allow, check or block on your store. Give it your traffic and flows. You get a policy, limits and alerts.
  • A one-page policy: who is allowed, checked or blocked at each step
  • A rules table per flow with what to count, the limit and what happens next
  • Exact wording for sign-in, reset and sign-up messages
  • Alerts to set, a monthly review list and a plan by week
• AI app and chatbot builder: Describe the chatbot, document question answerer or tool-using agent you want. Get starter code for your AI app in Python with LangChain.
  • Starter Python code for your chatbot, question answerer or agent
  • Install commands for the right packages
  • A document search setup, if your app needs one
  • An example of an agent that uses tools
  • A note on when a different library is a better fit
  Source: Orchestra Research.
• AI project context organiser: Share your project and next task. Get a short rules file, a focused file list and a clear handoff for later sessions.
  • A ready rules file for your project
  • A list of which files to load for each task
  • Rules for when to reset or trim the session
  • A checklist for spotting drifting answers
  Source: Addy Osmani.

Tasks you can use it for

• Your team works in Feishu or Lark and you want alerts or approvals to run there, not by email.
• You need orders or records from another system to appear in a Feishu table.
• A developer needs a clear list of permissions to request before asking the admin.
• A bot or message card is failing and you want a checklist of the usual causes.

Limits to check before starting

• You want changes made in your Feishu account now. This agent writes plans and code sketches. Your admin must create the app and approve its permissions.
• You want an API or webhook design for another system. Use the API Platform Engineer agent.
• You are deciding which workflows to automate first, and who owns them. Use the Automation governance planner.

Best way to use this role

Give it one clear outcome, the actual files and a definition of done. Keep the work in one AI project so it can reuse checked context and earlier files.

• Download the pack from this page and add it to your AI as a skill. If you cannot, paste SKILL.md into a new chat, then paste references/source-agent.md.
• Describe the job in plain words. Say who triggers it, who sees the result and which other systems are involved.
• Say if you use Feishu or Lark, and if the app is for your own company only. Add any code or error messages you have.
• Type "Plan this integration. List each permission with a reason. Mark anything I should check in the current Feishu docs."
• Read the permission list and the open questions first. Ask your admin whether each permission can be granted.
• Give the build order and the launch tests to your developer. Ask for code sketches only if they need them.

Read it as data

Read the complete role setup as JSON. Connect your AI to the AI Blocks MCP library and read aiblocks://roles/engineering-feishu-integration-developer for its role instructions and pinned sources.

This is a prepared AI role. No task has run. Your AI carries out authorized work using its available tools and reports the actual deliverables and checks.