Results for “ty”

Define the types and shared registrations needed to add a syncable entity to Twenty's server. Set up database entities, editable fields, action types, and relationships as the foundation for workspace migration implementation.

• Define a new syncable entity in Twenty
• Create flat data and migration action types
• Register editable fields and comparison rules

Design reusable TypeScript components and API types with checks at compile time. Use generics, conditional rules, property transformations, and string patterns to derive types from existing definitions and verify how those types behave.

• Designing API clients with compile-time type checks
• Creating reusable components and helper types
• Defining types for configuration and state management

Design TypeScript types and APIs that catch mistakes such as mixed-up identifiers and missing state handling. Implement reusable types and runtime checks that narrow types, configure tRPC for shared client-server types, and improve compiler settings.

• Prevent identifier mix-ups with distinct types
• Model application states and handle every case
• Create reusable types for complex data

Guide changes to Ghostty within cmux, including optimized GhosttyKit builds and upstream updates. Defines how to publish submodule commits, update the parent repository’s reference, and document fork changes so future checkouts can retrieve the required code.

• Rebuilding GhosttyKit after changes
• Bringing upstream Ghostty updates into a fork
• Updating the parent repository’s submodule reference

Audit a codebase with three vulnerability hunters and two engineers who build small demonstrations of suspected flaws. Verify attack paths, assess severity from demonstrated impact, and report evidence, targeted fixes, and checks to prevent recurrence.

• Review security before a release
• Audit security risks in a pull request
• Verify whether a suspected flaw is exploitable

Implement caching and data conversion for syncable entities in Twenty's server code. Build lookup maps, convert stored records and inputs into flat representations, and resolve references to universal identifiers for later validation and processing.

• Build a cache service for a new syncable entity
• Convert stored entities into flat data
• Transform creation and update inputs

Implement database action handlers for syncable entities in Twenty server internals. It covers create, update, and delete operations, with conversion from universal identifiers to database IDs before each action is executed.

• Implement create, update, and delete handlers for a new entity
• Convert universal relation identifiers into database IDs
• Check runner implementation before the integration step

Build automated responses to AWS GuardDuty security findings using EventBridge and Lambda. Configure severity filters, isolate EC2 instances, disable compromised access keys, preserve disk snapshots for investigation, and send notifications to security teams.

• Triggering responses to high-severity GuardDuty findings
• Isolating EC2 instances and preserving investigation data
• Disabling compromised IAM access keys

Prepare SaaS teams for SOC 2 audits by mapping evaluation criteria to controls, the measures used to manage risk. Build control matrices, track supporting evidence, identify gaps, and assess readiness for Type I or Type II.

• Build a matrix of controls, owners, and evidence requirements
• Identify gaps in Type I or Type II audit preparation
• Track evidence collection for each control

Knowledge base from the FAA System Safety Handbook (Dec 30, 2000). Use for system safety as a specialty within systems engineering: the five-step safety risk management process (mandated by FAA Order 8040.4 and the AMS), the severity-by-likelihood risk matrix and acceptance bands, the Safety Order of Precedence, system-description models (5M, SHEL(L)), the hazard-analysis activities (PHL/PHA/RHA/SSHA/SHA/O&SHA/HHA), integrated system hazard analysis, the analysis techniques (FTA, FMEA/FMECA, Fault Hazard, Common Cause, Sneak Circuit, Energy Trace), closed-loop hazard tracking (Safety Action Record), and the specialty domains the handbook covers — acquisition-lifecycle safety and contracting (OSA/CSA/SSPP/ISSPP), software safety (control-capability ranking, SHCM, DO-178B), test & evaluation safety, facilities safety, commercial launch safety (AST licensing, expected casualty, MPL/DAMP), system safety training, and Operational Risk Management (ORM) with human/organizational factors. Scope limits: this is a year-2000 FAA how-to; it predates the modern FAA/ICAO Safety Management System (SMS) and Just Culture regulatory frameworks, and many cited orders, advisory circulars, and launch-licensing rules have since been restructured. It is FAA/NAS-centric, leans on MIL-STD-882C, and does not define the SE life-cycle processes themselves (use nasa-npr-7123 / dau-se-guidebook) or reproduce third-party standard text (MIL-STD-882, DO-178B, ISO/IEC/IEEE).

The English summary is being prepared. Showing the original description.

Create a new app that extends a running Twenty instance. Guide project naming and instance selection, then use the scaffolder to install dependencies, authenticate, initialize Git, and complete the initial sync and installation.

• Start a new Twenty app project
• Scaffold a CRM extension or integration
• Create an app connected to an existing Twenty instance

Build custom video session experiences in Unity using Zoom Video SDK wrapper APIs. Follow guidance on connecting SDK events to scenes and interface state, with references for session joining, lifecycle management, compatibility, and troubleshooting.

• Integrating Zoom Video SDK into a Unity app
• Connecting video session events to Unity scenes and interface state
• Checking session joining and lifecycle patterns

Audit and strengthen security for applications running on GKE. Configure pod traffic restrictions, sandbox isolation, namespace security standards, and Secret Manager volume mounts to protect workloads at the application and namespace level.

• Auditing GKE security settings
• Restricting communication within a namespace
• Isolating risky pods and applying security standards

Automate Agenty tasks through Rube MCP, a connection to external tools. The skill discovers available operations and their required inputs, checks the Agenty connection, and executes tasks using the tools it finds.

• Finding available Agenty operations
• Running Agenty tasks through an agent
• Processing multiple Agenty operations together

Test Omnigent’s native Antigravity integration with a live local server and the real agy CLI. Verify messages traveling between the web interface and terminal, mirrored replies, permission requests, interruption, session resumption, and process cleanup.

• Testing message delivery from the web interface to agy
• Checking terminal output against mirrored session replies
• Verifying permission requests and interruption

Build charts and interactive diagrams in TypeScript with explicit data types and clear component boundaries. Guides library selection, data validation, interaction design, and shareable view settings to support maintainable visualization code.

• Choose a visualization library for a TypeScript app
• Refactor a D3 prototype into maintainable TypeScript
• Define data types for selections and tooltips

Configuring Salesforce opportunity management: sales stages, sales processes, opportunity record types, Path configuration, opportunity teams, opportunity splits, and forecasting categories. Use when setting up or restructuring the opportunity lifecycle for Sales Cloud. NOT for forecast types, rollup methods, quotas or manager adjustments — use admin/collaborative-forecasts. NOT for agreeing what the stages and exit criteria should be before any build — use admin/sales-process-mapping. NOT for CPQ pricing or product configuration. Keywords: BusinessProcess, sales process, OpportunityStage, ForecastCategoryName, PathAssistant, OpportunitySplit, OpportunitySplitType, OpportunityTeamMember, Opportunity.settings, enableOpportunityTeam, IsClosed, IsWon, IsPrivate.

The English summary is being prepared. Showing the original description.

Google TypeScript Style Guide reference for writing, reviewing, and refactoring TypeScript code. Use this skill whenever you are writing TypeScript code, reviewing TypeScript code, refactoring TypeScript, configuring ESLint or linter rules for TypeScript, or when the user asks about TypeScript coding conventions, naming conventions, type system best practices, or import/export patterns. Also trigger when the user mentions 'Google style', 'gts', 'TypeScript style guide', or asks 'how should I name this', 'should I use interface or type', 'how to handle null/undefined' in a TypeScript context. TypeScriptを書く・レビューする・リファクタリングする、ESLintの設定をする、「命名規則」「型の使い方」「import/exportのルール」「interfaceとtypeどっち」「anyを使っていい？」「nullチェックどうする」「Google式」「コーディング規約」「スタイルガイド」などの質問にも対応します。TypeScriptのコードに関する質問や作業であれば積極的にこのスキルを使ってください。

The English summary is being prepared. Showing the original description.

Automate Agenty tasks through Rube MCP, a connection to external tools. The skill discovers available operations and their required inputs, checks the Agenty connection, and executes tasks using the tools it finds.

• Finding available Agenty operations
• Running Agenty tasks through an agent
• Processing multiple Agenty operations together

Create a reusable design guide covering colors, typography, layout, and motion. Extract styles from existing sources or start from scratch, then turn the guide into instructions or code for supported video, slide, and design tools.

• Creating a design guide from a desired mood
• Extracting visual rules from a website or brand PDF
• Applying one style to videos, slides, and designs

Connect syncable entity components within Twenty server internals and expose them through GraphQL, an API query interface. It guides NestJS module registration, business services, response data conversion, and consistent handling of validation and execution errors.

• Register builders, validators, and action handlers in NestJS modules
• Connect entity creation to validation and migration execution
• Expose entities through GraphQL with response data conversion

Implement validation and migration action builders for syncable entities, data types handled by Twenty's synchronization system. This skill covers required fields, uniqueness, reference checks, and orchestration wiring, with validators that return errors without throwing exceptions or changing data.

• Add required-field and duplicate checks
• Validate references to parent entities
• Build create, update, and delete migration actions

Create integration tests for syncable metadata entities in Twenty itself. Cover invalid inputs, validation errors, and successful data operations, using reusable GraphQL request helpers, error snapshots, and cleanup routines to organize the test suite.

• Add integration tests for a new syncable entity
• Test required fields, duplicates, and invalid references
• Verify successful creation, updates, and deletion

Plan and improve customer or fan communities with platform recommendations, launch plans, welcome journeys, recurring activities, and ambassador programs. The skill also reviews participation metrics to identify where members disengage and suggest practical priorities for community managers.

• Plan a community launch from scratch
• Improve welcome journeys for new members
• Design recurring events and discussion threads