Skip to main content

RDT Workshop: AI-Powered SAMO Development

Header

Level: Intermediate

Keywords: RDT, VS Code Extension, SAMO Pilot, MCP Server, Claude Code, OpenAI Codex, IntelliSense, Kubernetes, AI-assisted development

The result: participants can install, configure, and use the full RDT toolchain — VS Code Extension, MCP Server, and SAMO Pilot — for scaffolding, deploying, and AI-assisted development of SAMO projects

Duration: 3 hours (including two 10-minute breaks)

Workshop Overview​

This hands-on workshop introduces the Rapid Development Toolkit (RDT) — a suite of three integrated tools that accelerate SAMO platform development:

ToolPurposeKey benefit
RDT VS Code ExtensionIDE integration for SAMO metadata, deployment, and validationIntelliSense, one-click K8s deploy, JSON schema validation
SAMO MCP ServerModel Context Protocol server with 30+ AI-accessible toolsAI tools can search docs, lookup schemas, scaffold projects
SAMO PilotAI coding agent plugin (Claude Code & OpenAI Codex)AI understands all 3 SAMO layers, generates configs, validates consistency

AI Coding Agent = Claude Code or OpenAI Codex — SAMO Pilot works with both.

The exercises build progressively: scaffold a project → explore with IntelliSense → deploy to Kubernetes → use AI to extend it → sync changes back.

Agenda​

TimeSectionDuration
0:00 – 0:151. Introduction & Environment Check15 min
0:15 – 0:302. Install All Three Tools15 min
0:30 – 1:053. RDT VS Code Extension35 min
1:05 – 1:15Break10 min
1:15 – 1:504. SAMO MCP Server35 min
1:50 – 2:355. SAMO Pilot — AI-Assisted Development45 min
2:35 – 2:45Break10 min
2:45 – 3:006. Capstone Exercise & Wrap-Up15 min

Pre-Workshop Checklist​

Must be completed before the workshop

All prerequisites must be installed and verified before you arrive. The workshop does not budget time for setup from scratch.

Open the full Prerequisites Guide — it covers software installation, Kubernetes access, npm registry setup, Helm login, and includes a verification script.

1. Introduction & Environment Check​

Duration: 15 minutes (5 min presentation, 10 min hands-on verification)

Learning objectives​

  • Understand the RDT toolchain architecture and how the three tools relate
  • Verify that all prerequisites are met

Architecture​

The three RDT tools form a layered system:

LayerToolRole
IDE ProductivityVS Code ExtensionIntelliSense, scaffolding, deploy, sync, JSON validation
KnowledgeMCP Server30+ tools for docs search, schema lookup, scripting API, project creation, server management
AI OrchestrationSAMO PilotSkills, agents, and prompts that coordinate AI across all 3 SAMO layers (works with Claude Code & Codex)

AI coding agents in 2 minutes​

If you haven't used an AI coding agent before, here's the basics:

ConceptHow it works
StartRun claude in your terminal from the project directory
PromptType a natural language request and press Enter
Tool callsClaude calls tools (read files, run commands, MCP tools) — you approve or deny each one
MCP toolsTools from SAMO MCP Server appear as mcp__samo-mcp-server__<tool_name> — approve them to let Claude access SAMO docs and schemas
PluginsManage with /plugin — list, add, configure, remove
StopPress Esc to interrupt, or type /exit to quit
tip

Both agents work the same way with SAMO Pilot — the skills, agents, and MCP tools are identical. The only differences are in installation and configuration commands.

Exercise — Environment verification (10 min)
  1. Run the verification script from the Prerequisites Guide
  2. Confirm all items show OK (not MISS or FAIL)
  3. Confirm kubectl cluster-info shows the SAMO K8s cluster endpoint
  4. If anything fails, raise your hand — helpers will assist

Troubleshooting:

IssueFix
kubectl cluster-info failsConnect to VPN first, or request kubeconfig from organizer
@samo:registry emptyFollow the npm scope setup
Node.js wrong versionInstall Node.js 22.x from nodejs.org

2. Install All Three Tools​

Duration: 15 minutes (5 min demo, 10 min hands-on)

Learning objectives​

  • Install the RDT VS Code Extension from a .vsix file
  • Install SAMO Pilot in your AI coding agent (Claude Code or Codex)
  • Understand that the MCP Server is bundled with SAMO Pilot (no separate install needed)

2.1 RDT VS Code Extension​

Option A — UI:

  1. Open VS Code
  2. Go to Extensions view (Ctrl+Shift+X)
  3. Click ... (More Actions) → Install from VSIX...
  4. Select the .vsix file provided by the organizer
  5. Reload VS Code if prompted

Option B — Command line:

code --install-extension samo-rdt-<version>.vsix

After installation, the RDT icon appears in the Activity Bar (left sidebar).

2.2 SAMO Pilot (AI Coding Agent Plugin)​

# Open a terminal in your project directory
cd your-workspace-folder/
claude

# Inside Claude Code:
/plugin marketplace add https://gitlab/samo/server/tools-implementation/samo-pilot.git

When prompted, enter your GitLab username and personal access token (provided by the organizer).

Then configure the plugin:

/plugin config samo-pilot

You'll be prompted for three values:

SettingValueDescription
gitlab_tokenusername:token (provided by organizer)For project scaffolding via GitLab
base_urlhttps://rdt-<your-name>.samo-kube.assecosk.localYour SAMO deployment URL (set after K8s deploy)
lids_credentialsadministrator:berit (provided by organizer)For LIDS management API calls

All values are stored securely by Claude Code and never written to disk.

SSL error during plugin install?

If you see an SSL certificate error, run this first and retry:

git config --global http.sslBackend schannel

2.3 SAMO MCP Server​

The MCP Server is automatically included with SAMO Pilot. When you use your AI coding agent with the plugin installed, the MCP server starts in the background via npx @samo/mcp-server.

For standalone use with other AI clients (VS Code Copilot, Claude Desktop), see the MCP Server documentation.

Exercise — Verify installation (10 min)
  1. RDT Extension: Open VS Code, confirm the RDT icon is in the Activity Bar. Press Ctrl+Shift+P and search for SAMO RDT — you should see commands like Deploy to Kubernetes
  2. SAMO Pilot: Verify the plugin is installed:
    • Claude Code: run /plugin and confirm samo-pilot appears under Installed
    • Codex: run codex plugin list and confirm samo-pilot appears
  3. MCP Server: Ask your agent: "Check if my GitLab token is valid" — SAMO Pilot should call the check_gitlab_token MCP tool

Troubleshooting:

IssueFix
RDT icon not visibleReload VS Code window (Ctrl+Shift+P → Developer: Reload Window)
Plugin not foundExit your agent, restart, retry the marketplace add command
MCP server fails to startVerify @samo scope: npm config get @samo:registry

3. RDT VS Code Extension​

Duration: 35 minutes total

This section covers three core features: IntelliSense, Project Scaffolding, and Kubernetes Deployment.

3A. IntelliSense & JSON Validation (12 min)​

Learning objectives​

  • Use autocompletion for ft_, cl_, at_, cf_ identifiers
  • Use dot-notation completion for feature type attributes and codelist columns
  • Navigate to definitions with Ctrl+Click

How it works​

When you open a workspace containing model.xml files, the extension:

  1. Scans all model.xml files
  2. Builds an in-memory Trie index for fast prefix-based lookups
  3. Registers autocompletion providers for ft_, cl_, at_, cf_ prefixes
  4. Registers go-to-definition providers for Ctrl+Click navigation

Autocompletion triggers​

You typeExtension suggests
ft_ + charactersFeature types matching the prefix
ft_xxx.All attributes of ft_xxx (including inherited)
cl_ + charactersCode lists matching the prefix
cl_xxx.Columns of cl_xxx
cf_ + charactersFiltered code lists matching the prefix
at_ + charactersAll attributes across the entire model
Instructor

Demo (5 min):

  1. Open the provided sample SAMO project (with model.xml files)
  2. In any text file, type ft_ — show autocomplete popup with feature types
  3. Type ft_waterPipe. — show attribute suggestions including inherited ones
  4. Ctrl+Click on a ft_ identifier to jump to model.xml
  5. Open rdt.json — show validation (add an unknown property to trigger red squiggles)
Exercise — IntelliSense (7 min)

Using the sample project provided by the organizer:

  1. Autocomplete: Open any file and type ft_ — browse the available feature types. Pick one and note the attribute count shown in the suggestion detail
  2. Dot notation: Type ft_waterPipe. (or a feature type from your model) — explore the attribute list. Can you spot which attributes are inherited from a parent?
  3. Go-to-definition: Ctrl+Click on three different identifiers (ft_, cl_, at_). Use Alt+Left Arrow to navigate back
  4. Validation: Open the rdt.json file, add a property "foo": "bar", and observe the validation error. Then delete it

Tip: If IntelliSense feels stale after switching branches, reload the window (Ctrl+Shift+P → Developer: Reload Window).

3B. Project Scaffolding — SAMO Init (10 min)​

Learning objectives​

  • Use the SAMO Init wizard to scaffold a complete SAMO project
  • Understand the 13 template placeholders and resulting project structure
  • Understand how rdt.json is auto-generated per environment

The SAMO Init wizard​

Launch: Click Create SAMO Init Project in the RDT Activity Bar.

The wizard collects parameters in three sections:

Project Identity:

FieldExample
Primary Color#1976D2
Project IDworkshop-jan
Security App MethodWORKSHOP_JAN
Server Namesamo-dev.local

Service Versions:

FieldExample
LIDS Version / Port3.2.1 / 8080
Gateway Version / Port2.1.0 / 8081
Dynamic App Version1.5.0

Database Configuration:

FieldExample
DB Provider / Driverpostgresql
DB URLjdbc:postgresql://localhost:5432/samo
DB User / Passwordsamo_admin / ********

After submission, the wizard:

  1. Clones two GitLab template repos (samo-init-configuration, samo-init-project)
  2. Replaces 13 template placeholders in files and directory names
  3. Copies results into your workspace
  4. Auto-generates rdt.json for each environment directory

Resulting project structure:

<project-id>/
├── configuration/
│   └── packages/        # SAMO configuration packages
└── project/
    ├── ...              # Model and project files
    └── environments/
        └── <env>/
            ├── rdt.json                  # Auto-generated deploy config
            ├── *.properties              # Environment property files
            └── ...
Instructor

Demo (5 min): Walk through the SAMO Init form live, explain each section, submit, and show the resulting project structure. Highlight the auto-generated rdt.json.

Exercise — Scaffold your project (5 min)

Each participant scaffolds their own project:

  1. Click Create SAMO Init Project in the RDT Activity Bar
  2. Fill in the form using these workshop values:
    • Project ID: workshop-<your-name> (e.g., workshop-jan)
    • Primary Color: choose any color you like
    • Other fields: use the defaults provided by the instructor
  3. Submit and wait for the wizard to complete
  4. Browse the generated project: open configuration/packages/, project/, and the rdt.json file in the environment directory

3C. Kubernetes Deployment & Sync (13 min)​

Learning objectives​

  • Deploy the scaffolded project to K8s with one click
  • Understand the deployment pipeline (Helm install, ConfigMaps, config copy, restarts)
  • Use Kubernetes Sync to push incremental changes

Deployment pipeline​

Click Deploy to Kubernetes in the RDT Activity Bar (or Ctrl+Shift+P → SAMO RDT: Deploy to Kubernetes).

The 10-step pipeline:

Each participant gets a personal namespace derived from their OS username (e.g., rdt-jan).

Kubernetes Sync​

After deployment succeeds, the sync status bar appears in the bottom-right of VS Code:

Status bar stateMeaning
Sync: <namespace> (gray)Idle — no pending changes
Sync (N) (yellow)N files changed — click to choose sync action
Syncing... (spinning)Sync in progress
Sync failed (red)Error — click for details

Sync actions (click the status bar when changes are pending):

  • Sync all — push metadata + update ConfigMaps
  • Sync metadata only — copy configuration/packages/ to pod, restart
  • Sync ConfigMaps only — update only changed ConfigMaps, restart affected services
  • Show changed files — list what changed
  • Ignore all changes — clear pending without syncing
Instructor

Demo (7 min):

  1. Click Deploy to Kubernetes, walk through subproject/environment selection
  2. Show the Output panel → "SAMO Kubernetes" channel as deployment runs
  3. After deploy: point out the sync status bar
  4. Edit a file in configuration/packages/ — show status bar turning yellow
  5. Click status bar → Sync metadata only — show incremental sync
  6. Edit a property file — show Sync ConfigMaps only and explain the targeted restart map
Exercise — Deploy and sync (6 min)
  1. Click Deploy to Kubernetes in the RDT panel
  2. Select your subproject and environment
  3. Watch the Output panel as deployment progresses (should take 2-3 minutes)
  4. After deployment succeeds, verify the sync status bar appears (gray, idle)
  5. Open any file under configuration/packages/, make a small change (add a comment), and save
  6. Observe the status bar turn yellow with Sync (1)
  7. Click the status bar → Sync metadata only
  8. Watch the status bar: yellow → spinning → gray (idle)

Troubleshooting:

IssueFix
Helm timeoutIncrease timeout: Settings → samo-rdt.kubeDeploy.helmTimeout → 10m
OCI pull failureRe-run helm registry login docker.asseco-ce.com
Pod not startingCheck Output panel for errors. Common: license file path wrong

4. SAMO MCP Server​

Duration: 35 minutes total

4A. MCP Concepts & Tool Categories (10 min)​

Learning objectives​

  • Understand what MCP (Model Context Protocol) is
  • Know the 7 tool categories and 30+ tools available

What is MCP?​

Model Context Protocol (MCP) is a standard for connecting AI models to external tools. The SAMO MCP Server runs as a local process (stdio transport) — your AI client launches it and communicates via standard input/output.

Tool categories​

The MCP server provides 30+ tools organized in 7 categories:

CategoryToolsWhat gets indexed
SAMO Projectcheck_gitlab_token, create_samo_projectGitLab templates
Documentation Searchsearch_docs, grep_docs, glob_docs, read_doc, list_sectionsSAMO Lighthouse Cookbook & Implementation Guide
Scripting APIlist_scripting_api_namespaces, search_scripting_api, get_scripting_api_builder, get_scripting_api_examplesLIDS Scripting API — namespaces, builders, methods, parameters
DynApp Module Cataloglist_modules, search_modules, get_module_schema, search_module_propertiesAll DynApp UI components with JSON schemas
DynApp Configurationlist_dynapp_configuration_schemas, search_dynapp_configuration_schemas, get_dynapp_configuration_schema, search_dynapp_configuration_schema_propertiesDynApp schemas — application, app-part, app-module, page-modules, entity-metadata, intents
Business Serverlist_business_server_schemas, search_business_server_schemas, get_business_server_schema, search_business_server_schema_propertiesBusiness server schemas — entities, services, triggers, workflows, actions, conditions
Server Managementcheck_env, health_check, diagnose_deployment, reload_config, sync_database, reindex_elasticsearchLive SAMO deployment — health, diagnostics, config reload, DB sync, ES reindex

Environment variables​

VariableRequiredDescription
SAMO_GITLAB_TOKENYesGitLab token for project scaffolding
DOCS_URLNoOverride docs source URL (default: public endpoint)
BUSINESS_SERVER_VERSIONNoOverride business-server schema version
DYNAPP_VERSIONNoOverride Dynamic App version
Instructor

Presentation (10 min): Walk through the 7 categories on screen. Explain that the MCP server builds in-memory indexes at startup (first call may take 5-10 seconds). Show the supported clients list: Claude Code, OpenAI Codex, VS Code Copilot, Claude Desktop.

4B. Hands-On with MCP Tools (25 min)​

Learning objectives​

  • Interact with MCP tools through AI agent conversations
  • Learn prompting patterns that trigger specific tool usage
Instructor

Demo (10 min): In your AI coding agent (with SAMO Pilot installed), demonstrate each tool category:

  1. Docs search: "Search the SAMO docs for how to configure entity coloring in DynApp" — observe search_docs call
  2. Scripting API: "What methods are available in api.business()?" — observe list_scripting_api_namespaces and get_scripting_api_builder
  3. Module catalog: "What properties does the SAMO Browse module have?" — observe search_modules and get_module_schema
  4. Business server: "Show me the schema for a business server entity configuration" — observe get_business_server_schema
  5. Server management: "Check if my SAMO deployment is healthy" — observe health_check call
Exercise 1 — Documentation Discovery (5 min)

In your AI agent, ask these questions and observe which MCP tools get called:

  1. "How do I configure a trigger in the business server that runs when an entity is created?"
  2. Follow up: "Show me an example of this in the SAMO cookbook"
  3. Observe the search_docs and grep_docs tool calls in the output

Goal: The AI can search the full SAMO documentation corpus on your behalf.

Exercise 2 — Scripting API Exploration (5 min)
  1. Ask: "List all available namespaces in the LIDS Scripting API"
  2. Ask: "Show me the api.http() builder — what methods does it have?"
  3. Ask: "Give me an example of making an HTTP GET request using the scripting API"

Goal: The AI can look up the full Scripting API (3,300+ lines of type definitions) on demand.

Exercise 3 — Schema Lookup (5 min)
  1. Ask: "What are the available DynApp configuration schemas?"
  2. Ask: "Show me the schema for the application part configuration"
  3. Ask: "What properties can I use in the entity-metadata configuration?"

Goal: Understand DynApp and Business Server schema tools as live reference lookups.

MCP troubleshooting
IssueFix
MCP server fails to startVerify @samo scope: npm config get @samo:registry
Tool call times outFirst call builds the index — wait 5-10 seconds, retry
Agent doesn't call MCP toolsRephrase with SAMO-specific keywords (e.g., "DynApp", "business server", "LIDS")

5. SAMO Pilot — AI-Assisted Development​

Duration: 45 minutes total

5A. Skills & Agents Overview (10 min)​

Learning objectives​

  • Understand SAMO Pilot's auto-triggered skills and when they activate
  • Know the 3 sub-agents and their roles
  • Understand that all skills and agents work identically in Claude Code and Codex

Plugin structure​

samo-pilot/
├── CLAUDE.md / AGENTS.md  # Platform knowledge (loaded every turn)
├── .mcp.json              # MCP server config (auto-launches)
├── agents/
│   ├── samo-planner.md    # Architecture planning
│   ├── samo-reviewer.md   # Cross-layer validation
│   └── samo-docs-researcher.md  # Docs research
├── skills/
│   ├── lids-modeler/      # XML metadata modeling
│   ├── business-logic/    # Business server patterns
│   ├── dynamic-app/       # DynApp frontend config
│   ├── module-catalog/    # DynApp module lookup
│   ├── samo-navigation/   # App parts, pages, menus
│   └── samo-project-planner/  # Project planning
└── .vscode/
    └── samo.d.ts          # TypeScript defs for SAMO JS API

Auto-triggered skills​

These skills activate automatically when you mention specific keywords — no explicit invocation needed:

SkillTrigger keywords
lids-modelerXML, metadata, model.xml, featuretype, attribute, codelist, symbology
business-logictrigger, workflow, action, validation, script, JS API, business-service
dynamic-appview, form, list, dashboard, UI, frontend, dynapp, navigation
module-catalogmodule schema, samo-browse, samo-dashboard, widget properties
samo-navigationapplication part, page, menu entry, dashboard page, part.json
samo-project-plannernew project, create project, plan, scaffold

Sub-agents​

AgentModelWhen used
samo-plannerSonnetBreaks requirements into FeatureTypes, plans all 3 SAMO layers
samo-reviewerSonnetReviews configs for cross-layer consistency (IDs, references, naming)
samo-docs-researcherDefaultSearches documentation via MCP to answer technical questions
Instructor

Presentation (10 min): Walk through the plugin structure, the auto-triggered skills table, and the 3 agents. Explain how skills activate based on keyword matching — no explicit invocation needed.

5B. Create a FeatureType with AI (20 min)​

Learning objectives​

  • Use natural language prompts to generate XML, business JSON, and DynApp JSON
  • Understand the files generated across all three SAMO layers
  • See how auto-triggered skills guide the AI to produce correct SAMO configs
Instructor

Demo (8 min):

  1. In your AI agent (in the scaffolded workshop project), prompt: "Create a new FeatureType called WaterPipe with attributes: diameter (double), material (string), length (double), installationDate (date), and a geometry of type linestring"
  2. Walk through what gets generated:
    • XML FeatureType definition in model.xml (with attributes, geometry, naming conventions)
    • Business server entity JSON configuration
    • DynApp entity-metadata JSON configuration
  3. Show each generated file and highlight cross-layer consistency (IDs match across files)
  4. Point out how the lids-modeler skill auto-activated and enforced correct XML naming conventions (ft_ prefix, at_ prefix, numeric IDs)
Exercise — Create a FeatureType (12 min)

Build a simple park management domain:

  1. Create the entity: Prompt your AI agent:

    "Create a new FeatureType called ParkBench with these attributes: location (string), material (string), condition (string), installationDate (date). Include a point geometry."

    • Watch the lids-modeler skill activate automatically
    • The AI should generate files across all 3 layers
  2. Review the generated files:
    • Find the XML entry in model.xml — check the attribute IDs and types
    • Find the business server entity JSON — check the entity definition
    • Find the DynApp entity-metadata JSON — check the UI configuration
  3. Extend with a codelist: Ask: "Add a codelist cl_benchMaterial with values: wood, metal, concrete, composite. Then use it as the type for the material attribute on ParkBench."
    • Observe the lids-modeler skill activating again
    • Check the generated XML
  4. Add an attribute: Ask: "Add a manufacturer attribute of type string to ParkBench"
    • Verify the new attribute appears in all 3 layers

Checkpoint: Open the generated files side-by-side. Do the IDs match across layers? Are naming conventions correct?

5C. Business Logic & DynApp with AI (15 min)​

Learning objectives​

  • Use auto-triggered skills to configure business server triggers and actions
  • Use auto-triggered skills to create DynApp navigation (app parts, pages)
  • Use the samo-reviewer agent to validate cross-layer consistency
Instructor

Demo (5 min):

  1. Prompt: "Create a trigger that validates the condition attribute of ParkBench is not empty when saving" — observe business-logic skill
  2. Prompt: "Create a DynApp page that shows a browse list of all park benches with columns for location, material, and condition" — observe dynamic-app and samo-navigation skills
  3. Prompt: "Review the ParkBench configuration for cross-layer consistency" — observe samo-reviewer agent
Exercise — Extend with business logic and UI (10 min)

Continue building the park management domain:

  1. Plan the system: Prompt: "Plan a park bench maintenance tracking system with ParkBench and MaintenanceRecord entities"

    • Observe the samo-planner agent producing a 3-layer implementation plan
    • Review the plan before proceeding

  2. Add a validation trigger: Prompt: "Add a validation trigger on ParkBench that ensures installation date is not in the future"

    • Check the generated business server trigger JSON

  3. Create DynApp navigation: Prompt: "Create a DynApp application part called 'Park Assets' with a page showing a browse list of park benches"

    • Check the generated application.json, part.json, and page configuration

  4. Validate everything: Prompt: "Review all the ParkBench configuration we've created for consistency issues"

    • Observe the samo-reviewer agent checking cross-layer references
    • Fix any issues it identifies

  5. Sync to K8s: If time permits, use the Kubernetes Sync status bar to push your changes to the running pod

Tips for effective AI interaction
  • Use exact trigger keywords from the skills table (e.g., "trigger" not "hook", "DynApp" not "frontend")
  • The AI generates a best-effort config — always review generated files before deploying
  • The samo-reviewer agent is your safety net — use it after generating configs
  • If the AI places files in wrong directories, specify the expected path explicitly

6. Capstone Exercise & Wrap-Up​

Duration: 15 minutes (10 min exercise, 5 min wrap-up)

Capstone challenge​

Chain all three tools together in a realistic end-to-end workflow:

Exercise — End-to-End Workflow (10 min)

Starting from the project you built in Sections 3-5:

  1. Plan with AI: Prompt: "Add a Tree entity to the park management system with species (string), height (double), and planting date (date) attributes. Include a point geometry."
  2. Generate with AI: Let the AI generate all 3 layers (XML, business JSON, DynApp JSON) — review the output
  3. Verify with IntelliSense: In VS Code, type ft_tree. — confirm attribute suggestions appear (the Trie index updates live when model.xml changes)
  4. Look up a module: Ask your agent: "What DynApp module should I use to show a detail view of a tree?" — observe the MCP module catalog lookup
  5. Sync to K8s: Use the sync status bar to push your changes

You have now used all three tools in a single workflow: SAMO Pilot (AI generation) → VS Code Extension (IntelliSense verification + K8s sync) → MCP Server (schema lookup).

Wrap-up​

Key takeaways:

  • RDT VS Code Extension eliminates manual work: scaffolding, deployment, file sync, and IntelliSense
  • SAMO MCP Server gives AI tools access to the full SAMO documentation, Scripting API, and schema corpus
  • SAMO Pilot orchestrates AI (Claude Code or Codex) across all 3 SAMO layers with auto-triggered skills and specialized agents
  • The three tools compose together — scaffold with Init, develop with IntelliSense + AI, deploy and sync with one click

Resources​

ResourceLink
RDT OverviewImplementation Guide → RDT
Installation GuideInstallation → RDT
IntelliSenseVS Code Extension → IntelliSense
Kubernetes DeploymentVS Code Extension → K8s Deploy
SAMO PilotSAMO Pilot → Overview
MCP ServerSAMO Pilot → MCP Server
SAMO CookbookTutorials → Cookbook

Support​

For access tokens, K8s cluster access, or tool issues, contact the RDT team at simon.misak@asseco-ce.com.