Results for “application”

Expert knowledge for Azure Application Gateway development including troubleshooting, best practices, decision making, architecture & design patterns, limits & quotas, security, configuration, integrations & coding patterns, and deployment. Use when configuring App Gateway v2 listeners/routing, WAF/TLS with Key Vault, AKS/AGIC, Private Link, or Containers, and other Azure Application Gateway related development tasks. Not for Azure Front Door (use azure-front-door), Azure Load Balancer (use azure-load-balancer), Azure Virtual Network (use azure-virtual-network), Azure Web Application Firewall (use azure-web-application-firewall).

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

Build Spring Boot 4.x applications following the best practices. Use this skill: * When developing Spring Boot applications using Spring MVC, Spring Data JPA, Spring Modulith, Spring Security * To create recommended Spring Boot package structure * To implement REST APIs, entities/repositories, service layer, modular monoliths * To use Thymeleaf view templates for building web applications * To write tests for REST APIs and Web applications * To write ArchUnit tests for testing architecture * To configure the recommended plugins and configurations to improve code quality, and testing while using Maven. * To use Spring Boot's Docker Compose support for local development * To create Taskfile for easier execution of common tasks while working with a Spring Boot application

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

App Builder - Application Building Orchestrator workflow skill. Use this skill when the user needs Main application building orchestrator. Creates full-stack applications from natural language requests. Determines project type, selects tech stack, coordinates agents and the operator should preserve the upstream workflow, copied support files, and provenance before merging or handing off.

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

Guides Kotlin HTTP server development with Ktor through examples for API routes, authentication, JSON conversion, and WebSockets. Shows how to organize application components with Koin and verify routes and authentication using integration tests.

• Building REST API routes with Ktor
• Protecting routes with JWT authentication
• Organizing application components with Koin

Develop applications through separate planning, building, and evaluation agents. The workflow tests the running app, scores its design and functionality, and feeds specific issues back into repeated development cycles with configurable quality thresholds and iteration limits.

• Turning a brief idea into an application specification
• Refining frontend design through separate evaluation
• Testing and improving full-stack application features

Build web search, page content retrieval, structured data extraction, and browser interactions into applications with Firecrawl. The skill guides endpoint selection, credentials, SDK or REST integration, and verification with a real request.

• Adding web search to an application
• Extracting structured data from known URLs
• Building website clicks and form filling into a workflow

Test local web applications with Python scripts using Playwright, a browser automation tool. Verify interface behavior, investigate problems, capture screenshots, and inspect browser logs, with a helper that manages one or more application servers.

• Verify buttons, links, and form behavior
• Investigate problems in dynamic web interfaces
• Capture screenshots of local applications

Plan and coordinate Strix security assessments across source code, running applications, APIs, and continuous integration pipelines. Combine findings into one prioritized remediation plan based on demonstrated impact, removing duplicates and documenting gaps in test coverage.

• Choosing suitable security tests for a product
• Planning a security assessment before launch
• Combining findings into a prioritized remediation plan

Build and improve Python command interfaces for GUI applications with OpenClaw. The skill guides source analysis, command design, testing, and packaging, including interactive sessions and structured JSON output for agents.

• Build a command interface for a GUI application
• Add missing commands to an existing interface
• Test workflows against the actual application

Use Codex to build Python command-line tools for applications with graphical interfaces. Analyze source code, add commands, test against the actual software, validate packaging and documentation, and discover tools already generated or installed.

• Build a command-line tool from application source code
• Extend an existing tool with more commands
• Test behavior against the actual application

Turn a plain language app request into a project plan, technology choices, and coordinated development tasks. Use project templates to structure web, mobile, desktop, API, or command line applications, with agents handling different development responsibilities.

• Build a full-stack app from a plain language request
• Choose technologies and structure for a new project
• Coordinate agents across UI, API, and database work

Coordinate specialist agents to investigate and improve application performance across databases, backend services, frontend code, and delivery infrastructure. Establish baseline measurements, address observed bottlenecks, validate changes with load tests, and set up monitoring to detect future slowdowns.

• Finding bottlenecks across an entire application
• Coordinating database, backend, and frontend improvements
• Validating performance changes with load tests

Develop Angular v20+ applications using Signals for reactive state and Standalone Components. Supports gradual migration from NgModules, Zoneless configuration, server-side rendering, hydration, and performance optimization with development testing before production use.

• Build a new Angular v20+ application
• Implement reactive state with Signals
• Gradually migrate NgModules to Standalone Components

Build Next.js applications with App Router patterns for page structure, data fetching, caching, and progressive page loading. Covers server and browser component responsibilities, route design, Server Actions, and migration from Pages Router.

• Build a new application with App Router
• Migrate an application from Pages Router
• Add progressive loading for slow data sources

Build Helm charts, reusable packages for deploying Kubernetes applications. Organize templates, manage configuration values for different environments, document settings, and validate charts before packaging or installation, with guidance for troubleshooting deployment and dependency problems.

• Create a Helm chart from scratch
• Package a Kubernetes application for distribution
• Manage deployment settings across environments

Turn an OpenAPI specification, a document describing an API, into an application using the chosen framework. Generate request handlers, data models, authentication, validation, tests, and setup instructions, with database access code where applicable.

• Build an API application from an existing specification
• Generate data models and request handlers together
• Prepare tests and setup documentation for a new project

Add a language to a Next.js application using next-intl. Translate every entry in the English message file, then update routing, middleware, and the language selector so the new language is included across the specified application files.

• Adding a language to a Next.js application
• Translating every entry in an English message file
• Updating routing and middleware for a new language

Add GraalVM Native Image support to Java applications to build native executables. The skill adapts Maven or Gradle configuration, fixes build errors iteratively, and checks application behavior, startup time, and memory use.

• Adding native executable builds to a Java application
• Configuring native builds for Maven or Gradle
• Fixing reflection and resource errors in native builds

Build Helidon 4 applications on Java 21 or later with guidance for SE and MP. Apply practical patterns for HTTP endpoints, database access, configuration, testing, and security while accounting for API changes from Helidon 3.

• Build HTTP APIs with Helidon SE or MP
• Review code for Helidon 3 to 4 API changes
• Organize database access and application configuration

Add Arize AX tracing to an LLM application, recording how model calls and tool executions connect. Inspect the existing code, select suitable integrations, add instrumentation, and verify that the application runs and traces reach Arize.

• Setting up tracing for an LLM application
• Recording tool inputs and outputs in an agent
• Adding Arize export to an existing OpenTelemetry setup

Investigate attacks that make legitimate Windows applications load malicious DLL files. This skill examines loading events, digital signatures, file hashes, and unusual locations, then checks process behavior to document suspicious cases and guide remediation.

• Investigating alerts about unsigned DLL files
• Hunting for persistent threats using legitimate applications
• Checking suspicious DLL loading paths

Investigate misuse of application identities in Microsoft Entra ID using audit and sign-in logs. Provides detection queries and investigation steps for suspicious credential additions, privileged role assignments, consent grants, and service principal enumeration.

• Investigating suspicious additions of application credentials
• Reviewing privileged roles assigned to application identities
• Building detection rules for Entra ID identity abuse

Assess iOS and Android app security using OWASP MASTG, a mobile security testing guide. Examine app files, runtime behavior, stored data, authentication, and API traffic, then document vulnerabilities, their impact, and suggested fixes.

• Assess mobile app security before release
• Check sensitive data storage and network traffic
• Test authentication and resistance to runtime manipulation

Helps build Angular v20+ applications with Signals, which track changing values, and self-contained Standalone Components. Covers state management, server rendering, performance improvements, and testing, including gradual updates to existing applications.

• Build a new Angular v20+ application
• Migrate NgModules to Standalone Components
• Design state management with Signals