DevDock User Guide and Capabilities

Welcome to DevDock's product guide. This document explains how DevDock helps developers and AI agents save, organize, retrieve, and reuse trusted engineering context.

DevDock is AI context infrastructure for developers. It connects reusable engineering context, prompts, snippets, commands, architecture, and workflows to AI agents through MCP.

Table of Contents

1. What is DevDock?
2. Core Workflow
3. Items
4. Item Types
5. Collections
6. Packs
7. Extensions
8. Shared Items
9. Search
10. Tags
11. Insights
12. AI Assistance
13. Files, Images, and Diagrams
14. Favorites, Pins, and Recent Work
15. Import, Export, and Trash
16. Common Workflows
17. Best Practices
18. Developer and Agent Examples
19. Troubleshooting

What is DevDock?

DevDock is an AI context layer for developers and AI agents. It gives prompts, snippets, commands, architecture notes, files, diagrams, and workflows one structured place to live so they can be found again by you or retrieved by an AI agent when needed.

Developers usually keep useful material scattered across code editors, AI chats, browser bookmarks, terminal history, notes apps, Slack threads, local files, and documentation pages. DevDock turns that scattered material into a reusable context layer for real work.

What DevDock Stores

DevDock can store:

• Code snippets
• AI prompts
• Terminal commands
• Architecture and technical notes
• Documentation links
• Uploaded files
• Images, screenshots, and diagrams
• Project context
• Reusable implementation patterns and workflows
• Shareable knowledge for teammates or external viewers

Why This Matters

• Less context switching - developers do not need to hunt through old tools.
• Faster reuse - trusted prompts, snippets, commands, and workflows are easy to find again.
• Better AI context - agents can retrieve the material they need instead of starting from an empty chat.
• Stronger working memory - decisions, architecture, and examples can be saved instead of disappearing in chat.
• Cleaner handoffs - a shared item, collection, or pack can explain a workflow without requiring a meeting.
• More consistent work - developers and agents can reuse proven patterns instead of recreating them.

Core Workflow

Most DevDock usage follows a simple loop:

1. Capture - save the prompt, snippet, command, architecture note, file, or workflow.
2. Organize - add a type, tags, collections, descriptions, and pinned/favorite status.
3. Retrieve - search manually or let an AI agent retrieve relevant context through MCP.
4. Reuse - copy a snippet, run a command manually, reuse a prompt, open a link, share an item, or provide it to an agent.
5. Improve - add private insights, generate descriptions, explain code, optimize prompts, or update stale material.

Example:

A developer solves a tricky deployment issue.

They save:
- The final terminal command as a Command item
- The explanation as a Note item
- The vendor documentation as a URL item
- A screenshot of the error as an Image item
- The follow-up debugging prompt as a Prompt item

Then they group all five into a "Vercel Deployment Debugging" collection.
Next time the issue appears, the whole workflow is searchable, shareable, and available as context for an AI agent.

Items

An item is the basic unit of knowledge in DevDock.

Each item has a title, type, optional description, optional tags, optional collections, and type-specific content such as code, text, a URL, or an uploaded file.

What Items Are Meant For

Items are for storing small to medium pieces of reusable intelligence. They should be specific enough to find quickly, clear enough for an AI agent to use, and useful enough to reuse later.

Good item examples:

• "React auth guard hook"
• "Docker reset local database"
• "Prompt: summarize support ticket"
• "Stripe webhook retry notes"
• "Postgres index debugging checklist"
• "API onboarding diagram"

Less useful item examples:

• "Random notes"
• "Stuff"
• "Important"
• "Project"

Common Item Actions

• Create a new item from the dashboard.
• Add tags to make the item easier to find.
• Add the item to one or more collections.
• Mark important items as favorites.
• Pin high-use items.
• Share an item through a public link.
• Add a private insight for your own thinking.
• Use AI tools to describe, tag, explain, or improve the item.
• Keep the content clean enough that it can be safely retrieved into an AI workflow.

Item Types

Item types help DevDock understand what kind of knowledge you are saving. Types make the workspace easier to browse, edit, and reuse.

Snippet

Purpose: Store reusable code fragments.

Use Snippet items for:

• Utility functions
• React hooks
• API handlers
• Database queries
• Validation schemas
• CSS patterns
• Config examples

Developer example:

Title: Type-safe fetch wrapper
Language: TypeScript
Tags: fetch, api, errors
Collection: Frontend Patterns

Team lead example:

Save the team's approved logging middleware as a Snippet so new services use the same pattern.

Product or sales example:

Use a shared Snippet item to show a customer how a sample integration works without exposing a full repository.

Prompt

Purpose: Store reusable AI prompts, agent instructions, and workflow templates.

Use Prompt items for:

• Code review prompts
• Bug investigation prompts
• Documentation writing prompts
• QA checklist prompts
• Product research prompts
• Support response prompts
• Agent task templates
• MCP retrieval instructions

Developer example:

Title: Senior backend review prompt
Tags: review, backend, quality
Collection: AI Workflows

Team lead example:

Create a prompt that asks an AI assistant to review pull requests against the team's architecture rules.

AI agent example:

Save the exact investigation prompt that reliably checks logs, reproduces the issue, and summarizes the fix.

Product example:

Save a prompt that turns customer feedback into a structured feature brief.

Sales example:

Save a prompt that converts technical discovery notes into a solution summary.

Command

Purpose: Store terminal commands, scripts, and operational recipes that developers or agents may need to reference.

Use Command items for:

• Git workflows
• Docker commands
• Database migration commands
• Deployment commands
• Local setup commands
• Debugging commands
• CLI sequences that are easy to forget

Developer example:

Title: Reset local database and seed data
Language: bash
Tags: database, local-dev, reset
Collection: Local Development

Team lead example:

Keep onboarding commands in one collection so new engineers do not rely on outdated Slack messages.

Important note: DevDock stores commands for reference. It does not guarantee that a command is safe or correct for every environment. Users should review commands before running them.

Note

Purpose: Store markdown-friendly technical notes, architecture context, decisions, and workflow explanations.

Use Note items for:

• Architecture explanations
• Debugging notes
• AI context notes
• Meeting notes
• Release notes
• Setup instructions
• API behavior summaries
• Decision records
• Implementation plans

Developer example:

Title: Why checkout retries use exponential backoff
Tags: checkout, resilience, architecture
Collection: Payments

Product example:

Save a plain-language note explaining why a feature has a technical limitation.

Team lead example:

Keep an "Engineering principles" collection made of Note items that explain team conventions.

AI agent example:

Save a "Repository architecture overview" note so agents can retrieve project boundaries before making code changes.

URL

Purpose: Store links to external resources.

Use URL items for:

• Documentation pages
• GitHub repositories
• Articles
• API references
• Design references
• Vendor dashboards
• Tutorials
• Internal docs

Developer example:

Title: Stripe webhook signature docs
URL: https://docs.stripe.com/webhooks/signature
Tags: stripe, webhook, security
Collection: Payments

Sales example:

Save customer-facing documentation links in a "Technical enablement" collection.

Product example:

Collect competitor or API reference links while researching integration scope.

File

Purpose: Upload and store documents, templates, configs, archives, and other file-based resources that belong in reusable context.

Use File items for:

• Markdown files
• JSON or YAML config examples
• PDFs
• Templates
• Exported reports
• Architecture docs
• Agent context files
• Sample payloads
• Zip archives

Developer example:

Title: Example GitHub Actions workflow
File: deploy-preview.yml
Tags: ci, github-actions, deploy
Collection: CI/CD

Team lead example:

Upload an onboarding checklist or service template that engineers should reuse.

Product example:

Attach a requirements document to the same collection as technical notes and diagrams.

Image

Purpose: Store screenshots, diagrams, visual notes, mockups, and references.

Use Image items for:

• Error screenshots
• Architecture diagrams
• UI mockups
• Whiteboard sketches
• API flow diagrams
• Before/after visual references

Developer example:

Title: Checkout retry flow diagram
Tags: checkout, retries, diagram
Collection: Payments

Product example:

Save a screenshot of a user-facing edge case next to the technical note that explains it.

Sales example:

Save architecture diagrams that help explain integrations during technical demos.

Custom Types

Custom item types allow a Pro workspace to model knowledge that does not fit the built-in types.

Use custom types for:

• API Contract
• Runbook
• Decision Record
• Agent Context
• Customer Example
• Demo Script
• Security Note
• Architecture Pattern

Example:

Custom type: Runbook
Title: Recover failed background jobs
Tags: ops, jobs, recovery
Collection: Production Operations

Use custom types when a repeated category deserves its own identity. If the material is rare, a tag or collection is usually enough.

Collections

Collections group related items together. A collection can contain mixed item types and can become a reusable context set for a developer or AI agent.

Unlike folders, collections are flexible. The same workflow can include snippets, prompts, commands, notes, links, files, images, and architecture context.

What Collections Are Meant For

Collections are best for grouping knowledge around a project, workflow, topic, team practice, architecture area, or customer scenario.

Collection Use Cases

Developer use cases:

• "React Patterns" with hooks, snippets, and component notes
• "Payments" with Stripe docs, webhook snippets, and retry commands
• "Local Development" with setup commands, environment notes, and config files
• "AI Workflows" with prompts and context notes
• "Agent Context" with architecture notes, task prompts, and trusted commands
• "Debugging Playbooks" with commands, notes, and screenshots

Team lead use cases:

• "New Engineer Onboarding"
• "Code Review Standards"
• "Production Runbooks"
• "Approved Architecture Patterns"
• "Release Checklist"

Product use cases:

• "Checkout Discovery"
• "Customer Feedback: Enterprise SSO"
• "Feature Scope: Reporting"
• "Implementation Constraints"

Sales and solutions use cases:

• "Demo Assets"
• "Integration Examples"
• "Common Customer Questions"
• "Security and Compliance Responses"

Example Collection

Collection: Stripe Webhooks

Items:
- URL: Stripe webhook signature docs
- Snippet: Verify webhook signature
- Command: Trigger local webhook event
- Note: Common retry behavior
- Image: Webhook event flow diagram
- Prompt: Explain webhook failure to a customer

Best Practices for Collections

• Keep collection names specific.
• Mix item types when they belong to the same workflow.
• Add descriptions when a collection is used by others.
• Favorite collections that represent active work.
• Use collections for project, workflow, or agent-context boundaries, and tags for cross-cutting labels.

Packs

Packs are reusable intelligence bundles built from collections.

A normal collection helps one user organize related items. A pack is a more intentional bundle that can be published, discovered, or reused as a complete set of knowledge by people or AI agents.

What Packs Are Meant For

Packs are useful when the value is not one item, but the combination of items.

Think of a pack as:

• A starter kit
• A reusable playbook
• A curated learning path
• A workflow bundle
• A stack-specific knowledge set
• An AI agent context bundle
• A team enablement package

Pack Use Cases

Developer use cases:

• "Next.js SaaS Starter Context"
• "Postgres Debugging Toolkit"
• "React Query Patterns"
• "Docker Local Dev Pack"
• "AI Code Review Workflow"
• "MCP Agent Context Pack"

Team lead use cases:

• "Backend Onboarding Pack"
• "Production Incident Response Pack"
• "Frontend Quality Standards Pack"
• "Release Manager Pack"

Product use cases:

• "Feature Planning Pack"
• "Customer Feedback Analysis Pack"
• "Technical Discovery Pack"

Sales and solutions use cases:

• "Pre-sales Technical Demo Pack"
• "Integration Discovery Pack"
• "Security Review Response Pack"

Example Pack

Pack: Frontend PR Review Kit

Includes:
- Prompt: Senior frontend code review
- Note: Component accessibility checklist
- Note: Frontend architecture boundaries
- Snippet: Standard loading state pattern
- URL: Internal design system docs
- Command: Run type-check and tests
- Image: Expected UI state matrix

Best for:
- New frontend engineers
- Team leads reviewing UI work
- AI agents reviewing frontend changes
- Contractors learning team standards

What Makes a Good Pack

• A clear name
• A short description
• Stack or topic tags
• Items that work together
• Enough context for someone new, including an AI agent, to understand why each item is included
• No private secrets, credentials, or customer-sensitive content

Extensions

Extensions help users capture knowledge from outside the DevDock dashboard.

The Chrome extension is designed for fast capture while browsing. It helps turn useful pages, snippets, notes, and references into DevDock items without switching tabs or manually copying everything later.

What Extensions Are Meant For

Extensions are for reducing capture friction.

Use extensions when:

• You are reading documentation and want to save the page.
• You find a useful snippet in an article.
• You want to save a reference before continuing work.
• You need to tag or file a resource without leaving the browser.
• You want DevDock to enrich a captured item with helpful metadata.

Extension Use Cases

Developer example:

While reading a database indexing article, save the page as a URL item, tag it "postgres" and "performance", and add it to the "Database Optimization" collection.

Product example:

While researching a competitor workflow, save relevant docs and screenshots into a "Reporting Research" collection.

Sales example:

While preparing for a customer call, save product docs and technical references into a "Customer Demo Prep" collection.

Team lead example:

During code review, save a reference article into a "Review Standards" collection for future reviewers.

Practical Tips

• Tag captured pages immediately while the context is fresh.
• Use collections to avoid creating a pile of unsorted links.
• Add a short description explaining why the page matters.
• Review captured items later and promote high-value items to favorites or packs.

Shared Items

Shared items let users turn selected DevDock items into public links.

Shared links are useful when someone needs to view a specific piece of knowledge without signing into your workspace.

What Shared Items Are Meant For

Shared items are for controlled, item-level distribution.

Use shared items for:

• Sending a code snippet to a teammate
• Sharing a prompt with a customer-facing team
• Publishing a reusable note
• Sharing a file or diagram
• Giving someone a direct link to technical context
• Letting another DevDock user save a shared item into their own workspace
• Sharing a cleaned-up prompt, snippet, or architecture note that others can reuse in their own AI workflow

How Sharing Works

• A private item stays private until a share link is created.
• A shared item can be viewed by anyone with the link.
• Shared pages are designed for reading and reuse.
• Share links can be revoked.
• Private insights are not shown on shared pages.
• Users can choose whether viewers can discover their other public shared items.

Shared Item Examples

Developer example:

Share "Exponential backoff retry wrapper" with another engineer so they can reuse the implementation in a different service.

Team lead example:

Share a code review prompt with the whole team so reviews follow the same expectations.

Product example:

Share a technical note with a product manager explaining why a feature needs a staged rollout.

Sales example:

Share a public architecture note during a customer conversation without exposing the rest of the workspace.

Discoverability

When sharing an item, the owner can decide whether viewers may browse other public items from the same owner.

Use discoverability when:

• You publish educational or reusable material.
• You want viewers to explore related examples.
• You are building a public technical profile.

Keep discoverability off when:

• The item is meant for one audience only.
• The context is sensitive.
• You do not want related shared items to be surfaced.

Search

Search is one of DevDock's main workflows because reusable intelligence only matters if it can be retrieved at the right moment.

The command palette helps users find items and collections quickly without navigating through every page. MCP gives AI agents another retrieval path into the same trusted library.

What Search Looks Across

Search can surface:

• Item titles
• Item types
• Descriptions and previews
• Tags
• Collections
• Recent items
• Recent collections

Search Use Cases

Developer use cases:

• Find a command you ran once and want to reuse.
• Search for a snippet by framework, language, or behavior.
• Find all saved prompts related to code review.
• Find architecture context before asking an AI agent to change a service.
• Jump to a collection without using the sidebar.

Team lead use cases:

• Find onboarding resources during a pairing session.
• Search for a standard runbook during an incident.
• Locate approved implementation examples.

Product use cases:

• Find notes related to a customer request.
• Search for saved technical constraints before scoping a feature.

Sales use cases:

• Find reusable integration examples.
• Locate a shared technical explanation for a customer question.

Search Examples

Query: webhook retry
Likely results:
- Note: Stripe webhook retry behavior
- Command: Trigger local webhook retry
- URL: Stripe webhook docs
- Collection: Payments

Query: auth
Likely results:
- Snippet: NextAuth session helper
- Prompt: Review authentication flow
- Note: Auth architecture boundaries
- Collection: Authentication

Search Tips

• Use stack names like "react", "postgres", "stripe", or "nextjs".
• Use workflow words like "deploy", "debug", "review", "onboarding", or "incident".
• Use agent-context words like "architecture", "constraints", "standards", or "workflow".
• Use tags consistently so search gets sharper over time.
• Add descriptions to items with unclear titles.

Tags

Tags are lightweight labels that connect related items across types and collections.

Collections answer "where does this belong?" Tags answer "what is this about?"

What Tags Are Meant For

Tags help users find related knowledge across the entire workspace.

Examples:

• react
• typescript
• auth
• stripe
• debugging
• performance
• onboarding
• customer-demo
• incident
• ai
• agent-context

Tag Use Cases

Developer use cases:

• Tag all database-related resources with postgres.
• Tag risky operational commands with production.
• Tag reusable AI prompts with ai.
• Tag architecture and workflow notes meant for agents with agent-context.
• Tag snippets by framework or language.

Team lead use cases:

• Tag onboarding resources with onboarding.
• Tag approved patterns with standard.
• Tag incident material with incident.

Product use cases:

• Tag implementation notes with scope, constraint, or customer-feedback.

Sales use cases:

• Tag reusable customer examples with demo, integration, or security.

Tagging Best Practices

• Prefer short, lowercase tags.
• Reuse existing tags instead of creating near-duplicates.
• Combine broad and specific tags, such as payments and stripe.
• Avoid using tags as full sentences.
• Use collections for larger topic grouping and tags for cross-cutting discovery.

Insights

DevDock supports two kinds of insight: private item insights and usage insights.

Private Item Insights

A private item insight is a personal note attached to an item. It is for thoughts, reminders, context, or follow-up work that should stay private.

Private insights are not shown on public shared item pages.

Use private insights for:

• "This command is safe only on staging."
• "Ask Maya before changing this pattern."
• "This prompt works best with a full diff."
• "Check if this API changed after version 2."
• "Good example for onboarding next quarter."

Developer example:

Item: Reset staging queue
Private insight: Only use after confirming no active replay job is running.

Team lead example:

Item: Pull request review prompt
Private insight: Add security review questions before sharing with backend team.

Product example:

Item: Enterprise SSO implementation note
Private insight: Revisit after customer contract terms are finalized.

Usage Insights

Usage insights help show how the workspace is being used. They can summarize activity such as item views, favorites, shares, and feature usage.

Use usage insights for:

• Understanding which knowledge is reused most often
• Identifying high-value shared resources
• Seeing whether a workflow is being adopted
• Spotting stale or underused material
• Measuring engagement with public shared items

Team lead example:

Review which onboarding items are actually opened by new engineers, then improve the ones that are ignored.

Product example:

Check whether shared technical notes are being viewed before customer workshops.

Sales example:

Look at which shared demo resources get the most engagement after technical calls.

AI Assistance

DevDock uses AI to improve the user's own library and to make saved knowledge easier to retrieve and reuse. It is not positioned as a general chatbot or autonomous coding platform.

AI assistance is focused on practical item-level tasks.

AI Capabilities

DevDock can help:

• Suggest relevant tags
• Generate concise descriptions
• Explain snippets and commands
• Optimize prompts
• Improve and reorganize notes
• Prepare context for future agent retrieval
• Summarize diagrams
• Convert supported snippets into flow diagrams
• Generate snippets from structured flow diagrams

AI Use Cases

Developer examples:

• Generate tags for a new TypeScript snippet.
• Explain an unfamiliar shell command before saving it.
• Convert a small function into a diagram for documentation.
• Turn a diagrammed flow into starter code.
• Improve a project-context note before using it with an AI agent.

Team lead examples:

• Improve a note before making it part of onboarding.
• Generate descriptions for a collection of approved patterns.
• Standardize review prompts.

Product examples:

• Improve a technical note so it is easier for non-engineers to read.
• Summarize a diagram before sharing it with stakeholders.

Sales examples:

• Clean up a technical explanation before sending it externally.
• Improve a reusable prompt for solution summaries.

AI Best Practices

• Treat AI output as a draft.
• Review generated tags and descriptions before saving.
• Do not put secrets, credentials, or private customer data into AI-assisted fields.
• Keep prompts specific and reusable.
• Save context in durable items instead of burying it in one-off chat messages.
• Add private insights when human context matters.

Files, Images, and Diagrams

DevDock can store more than text. Files and images help preserve context that does not fit neatly into a note or snippet.

Files

Use files for:

• Config examples
• PDFs
• Markdown files
• YAML or JSON templates
• Exported reports
• Sample payloads
• Project documents

Example:

File: example-webhook-payload.json
Collection: Payments
Tags: stripe, webhook, testing

Images

Use images for:

• Screenshots
• Whiteboard sketches
• Architecture diagrams
• UI mockups
• Visual bug reports

Example:

Image: auth-error-screenshot.png
Collection: Authentication
Tags: auth, bug, screenshot

Diagrams

Diagrams help turn technical flow into visual context.

Use diagrams for:

• Request lifecycle
• Retry behavior
• State machines
• Checkout flows
• API handoffs
• Onboarding explanations

Example:

Diagram: Checkout payment retry flow
Use it with:
- Note: Retry policy explanation
- Snippet: Retry utility
- URL: Payment provider docs

Favorites, Pins, and Recent Work

Favorites, pins, and recent activity help users keep important material close.

Favorites

Favorites are for items or collections that are important over time.

Use favorites for:

• Trusted snippets
• Active project collections
• Frequently used commands
• High-value notes
• Team-standard prompts

Pins

Pins are for items that should stay immediately visible.

Use pins for:

• The command you run every morning
• A release checklist during launch week
• A current incident runbook
• The prompt used for daily code review
• A customer demo script before a call

Recent Work

Recent items and recent collections help users return to work in progress.

Use recent work to:

• Reopen an item you just edited
• Continue organizing a collection
• Resume a debugging thread
• Find the last thing you saved from the browser

Import, Export, and Trash

DevDock supports lifecycle workflows around knowledge.

Import

Import is useful when existing knowledge lives outside DevDock.

Use import for:

• Migrating notes
• Saving config files
• Bringing in snippets
• Uploading templates
• Moving useful local files into the workspace

Export

Export is useful for portability, backup, compliance, or review.

Use export for:

• Personal backup
• Moving knowledge between tools
• Sharing a workspace archive with yourself
• Reviewing saved material offline

Trash

Trash protects users from accidental deletion.

Use trash when:

• Removing stale resources
• Cleaning old experiments
• Retiring outdated commands
• Reviewing deleted material before permanent removal

Best practice:

Delete stale items into trash first. Permanently delete only after confirming they are no longer referenced by active collections or packs.

Common Workflows

Workflow 1: Save a Reusable Snippet

1. Create a Snippet item.
2. Add the code and language.
3. Add tags like "typescript", "api", and "errors".
4. Add it to a collection such as "Backend Patterns".
5. Generate a description if the title is not enough.
6. Favorite it if it is a trusted pattern.

Workflow 2: Give an AI Agent Project Context

1. Create a collection called "Project Agent Context".
2. Add architecture notes, setup commands, coding standards, and key docs.
3. Save task prompts that tell the agent how to investigate, implement, and verify work.
4. Tag the items with "agent-context", stack names, and workflow names.
5. Turn the collection into a pack if it should be reused across agents or projects.
6. Keep secrets, credentials, and private customer data out of the collection.

Workflow 3: Build an Onboarding Collection

1. Create a collection called "Backend Onboarding".
2. Add setup commands, architecture notes, API links, and example snippets.
3. Pin the first item new developers should read.
4. Add tags like "onboarding", "backend", and "setup".
5. Turn the collection into a pack if it should be reused as a complete bundle.

Workflow 4: Share a Technical Explanation

1. Create a Note item explaining the topic.
2. Add related links, screenshots, or snippets to a collection.
3. Create a public share link for the note.
4. Decide whether viewers should discover other public shared items.
5. Send the link to the stakeholder.
6. Revoke the link later if it should no longer be public.

Workflow 5: Capture Research from the Browser

1. Open the relevant article or documentation page.
2. Use the Chrome extension to save the page.
3. Add a useful title, tags, and collection.
4. Add a short description explaining why it matters.
5. Review saved links later and promote the best ones to a pack or favorite collection.

Workflow 6: Improve an Existing Item

1. Open an item that is still useful but hard to understand.
2. Generate a concise description.
3. Suggest better tags.
4. Add a private insight with human context.
5. Move it into the right collection.
6. Share it only if it is ready for external viewing.

Best Practices

For Developers

• Save items when the context is fresh.
• Use precise titles.
• Add a short description to anything that might be unclear later.
• Keep commands reviewed and up to date.
• Use snippets for reusable code, notes for explanation, and collections for workflows.
• Save architecture, constraints, and workflow context that your AI agents repeatedly need.
• Add private insights when the item has caveats.
• Share only what is safe for public viewing.

For Team Leads

• Create collections for onboarding, reviews, releases, and incidents.
• Turn repeated team workflows into packs.
• Keep team-standard prompts and commands easy to find.
• Build agent-context packs for review, debugging, and implementation standards.
• Review old commands and runbooks regularly.
• Use shared links for lightweight handoff, not as a replacement for source control or formal docs.

For Product Teams

• Use notes and diagrams to understand implementation tradeoffs.
• Save technical constraints next to feature research.
• Ask engineers to share focused items instead of entire workspaces.
• Use collections for feature discovery and delivery context.
• Keep reusable prompts for turning technical context into planning, QA, or customer-facing summaries.

For Sales and Solutions Teams

• Use shared items for customer-safe technical examples.
• Save demo scripts, architecture diagrams, and public docs in collections.
• Avoid sharing internal-only notes, private insights, or customer-sensitive material.
• Keep reusable customer answers as notes or prompts.

Developer and Agent Examples

Developer Scenario

Goal: Reuse a proven authentication pattern.

DevDock setup:
- Collection: Authentication Patterns
- Snippet: Session helper
- Command: Run auth migration
- URL: Auth provider docs
- Note: Common edge cases
- Prompt: Review auth changes

Outcome:
The developer can search "auth session", open the collection, and reuse the complete context.

AI Agent Scenario

Goal: Give an AI coding agent the context it needs before changing authentication code.

DevDock setup:
- Pack: Authentication Agent Context
- Notes: Auth architecture boundaries, session lifecycle, security constraints
- Commands: Type-check, auth test suite, migration check
- URLs: Auth provider docs and internal API references
- Snippets: Session helper and middleware examples
- Prompt: Investigate auth change safely

Outcome:
The agent can retrieve trusted project context on demand instead of relying on a one-off prompt.

Team Lead Scenario

Goal: Onboard a new engineer faster.

DevDock setup:
- Pack: Backend Onboarding
- Notes: Architecture overview, service boundaries
- Commands: Local setup, test database reset
- URLs: Internal docs and external references
- Snippets: Approved API handler patterns

Outcome:
The new engineer gets a practical working library instead of scattered links.

Product Scenario

Goal: Understand why a feature needs phased delivery.

DevDock setup:
- Note: Technical constraints for reporting
- Image: Data flow diagram
- URL: Vendor API limitations
- Private insight: Product follow-up questions

Outcome:
Product can understand the tradeoff without reading the entire codebase.

Sales Scenario

Goal: Prepare for a technical customer demo.

DevDock setup:
- Collection: Enterprise SSO Demo
- Note: Customer-safe integration explanation
- Image: Architecture diagram
- URL: Public documentation
- Prompt: Summarize discovery notes into solution language

Outcome:
Sales can reuse approved technical material without asking engineering to rewrite it each time.

Troubleshooting

I cannot find an item

Try:

• Searching by tag instead of title
• Searching by technology name
• Checking recent items
• Looking inside related collections
• Searching for the problem, not the exact saved title

Example:

Instead of searching "my old fix", search "docker port conflict" or "postgres reset".

My workspace feels messy

Try:

• Creating collections for active workflows
• Adding tags to high-value items
• Favoriting only trusted resources
• Deleting outdated experiments into trash
• Turning repeated workflows into packs

I am not sure whether to use a tag or collection

Use a collection when the items belong to the same project, workflow, or bundle.

Use a tag when the label should connect items across many projects or collections.

Example:

Collection: Checkout Redesign
Tags: stripe, react, performance

I am not sure whether to share an item

Before sharing, check:

• Does it include secrets, credentials, tokens, or private customer data?
• Is the explanation clear enough for someone outside your workspace?
• Should viewers discover other public shared items?
• Is the item still accurate?

If in doubt, keep it private and share a cleaned-up note instead.

A command or snippet may be outdated

Update the item title or description to reflect status.

Examples:

Title: Legacy Docker cleanup command
Description: Use only for older local environments before the 2026 setup update.

Or move the item to trash if it should not be reused.

Summary

DevDock helps developers and AI agents turn scattered engineering context into practical, searchable, reusable intelligence.

Use items for individual resources, item types for structure, collections for workflows and agent context, packs for reusable bundles, tags for discovery, shared items for controlled distribution, insights for private context, and AI assistance for improving the quality of saved knowledge.

The best DevDock workspace is not a storage archive. It is a reusable system for remembering what worked, retrieving it quickly, and giving developers or AI agents the context they need on demand.