Name: syncable-entity-integration
Rating: 68.8 (1 reviews)
Author: twentyhq

syncable-entity-integration

Contributing to the Twenty codebase itself (twentyhq/twenty server internals), not for building apps on top of Twenty. Wire syncable entity services into NestJS modules, create service layer and resolvers for Twenty entities. Use when registering builders, validators, and action handlers in modules, creating business services, or exposing entities via GraphQL API with proper exception handling.

Quality

83%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

The canonical home for this skill is syncable-entity-integration in twentyhq/twenty

Quality

Content

75%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

Highly actionable, executable integration guidance with a clear sequenced workflow and verification checklist. The main weakness is repetition of the flat/DTO layering principle across several sections, which inflates length without adding clarity.

Suggestions

Consolidate the 'services return flat entities, resolvers convert flat→DTO' principle into a single authoritative statement (e.g., the Layer Responsibilities table) and remove its restatements in Quick Start, Step 4, and Step 5 to reduce repetition.

Add an inline validation feedback loop between the registration steps (e.g., 'After registering handlers, verify the module compiles / app boots before moving to the next module') to lift workflow clarity above the destructive/batch cap concern.

Move the full code templates for Steps 1-3 (module registration boilerplate) into a reference file and keep only the diff/essence inline, improving progressive disclosure for this 320-line skill.

Dimension	Reasoning	Score
Conciseness	Mostly efficient code-centric content, but the 'services return flat / resolvers convert flat→DTO' principle is restated ~4 times (Quick Start key principle, Step 4 service pattern, Step 5 resolver responsibilities, and the dedicated Layer Responsibilities section + bullets), which is noticeable padding that could be tightened.	3 / 5
Actionability	Every step ships full, copy-paste-ready TypeScript with concrete file paths and explicit imports (module registrations, service, resolver, conversion utility), covering the common cases; placeholders like '// ... existing imports' are appropriately marked.	5 / 5
Workflow Clarity	Steps 1-6 are clearly numbered and closed with a verification checklist, and the service code includes an explicit throw-on-validation-failure checkpoint; the gap is no inline validate→fix→retry feedback loop between the registration steps, keeping it just below a 5.	4 / 5
Progressive Disclosure	Well-organized into clear sections (Quick Start, Steps 1-6, Layer Responsibilities, Exception Interceptor, Checklist, Next Step) with one-level-deep, clearly signaled references to the sibling testing skill and the @creating-syncable-entity rule; no bundle files exist so structure is scored on the single file, which is good but not split across references.	4 / 5
	Total	16 / 20 Passed

Description

92%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong, specific description that clearly states both what the skill does and when to use it, with an explicit boundary that sharply reduces conflict risk. The only soft spot is trigger-term naturalness, where domain jargon dominates over user-paraphrased synonyms.

Dimension	Reasoning	Score
Specificity	Lists multiple concrete actions — 'Wire syncable entity services into NestJS modules', 'create service layer and resolvers', 'registering builders, validators, and action handlers', 'exposing entities via GraphQL API with proper exception handling' — giving comprehensive coverage of the skill's capabilities.	5 / 5
Completeness	Explicitly answers both 'what' ('Wire syncable entity services into NestJS modules, create service layer and resolvers for Twenty entities') and 'when' via a concrete 'Use when...' clause enumerating trigger scenarios, matching the top anchor.	5 / 5
Trigger Term Quality	Good keyword coverage with natural domain phrases ('register builders, validators, and action handlers', 'GraphQL API', 'service layer and resolvers'), but the terms are jargon-heavy and lack synonyms/variants a user might naturally phrase differently; not quite the comprehensive synonym coverage of a 5.	4 / 5
Distinctiveness Conflict Risk	A clear niche ('Contributing to the Twenty codebase itself (twentyhq/twenty server internals)') with an explicit disambiguator ('not for building apps on top of Twenty') that minimizes conflict with adjacent skills.	5 / 5
	Total	19 / 20 Passed

Validation

93%

Warnings & errors only

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 15 / 16 Passed

Validation for skill structure

Criteria	Description	Result
relative_links	Relative link issues: 1 suspicious	Warning

	Total	15 / 16 Passed

Repository: twentyhq/twenty
Path: .claude/skills/syncable-entity-integration/SKILL.md
Commit: 710f163

Reviewed: 1 day ago

Table of Contents

Discovery Implementation Validation

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.