Ramp published a post about Glass, the internal AI productivity suite they built for every employee. It's impressive work: auto-configured integrations, reusable skills, persistent memory, scheduled automations, Slack-native assistants, and 350+ skills reaching 99% adoption. Their post is worth reading in full.
If you want the same setup for your team, Devin supports these capabilities out of the box. No dedicated engineering team required. This post walks through each one and how to set it up.
Devin is an AI teammate that can write code and analyze data. Each session runs in its own cloud VM with a code editor, browser, terminal, and shell. Your repos are cloned, dependencies installed, and tools connected before Devin starts working. For data work, Devin includes a specialized Data Analyst agent (DANA) that queries your databases, builds visualizations, and answers business questions.
On top of this, Devin has a platform layer: integrations, reusable skills, persistent knowledge, org-wide playbooks, and scheduled automations.
You configure these once and they apply across your entire team. Glass built these capabilities as custom internal software. Devin ships them as configuration.
AI is useful when it can reach your tools. An engineer asks Devin to trace a Sentry error, check the recent PRs that touched the affected code in GitHub, and open a fix, all in one session. A sales lead asks Devin to pull a prospect's activity from HubSpot, cross-reference it with usage data in the database, and draft a personalized follow-up. Both work because everything is already connected.
Devin does this out of the box. Your org admin connects tools once, and every person on the team gets access to all of them in every session.
Devin has native integrations for GitHub, GitLab, Bitbucket, Azure DevOps, Slack, Microsoft Teams, Jira, and Linear. On top of that, the MCP Marketplace has 100+ additional integrations like Notion, Sentry, Datadog, Figma, PostgreSQL, Salesforce, Stripe, HubSpot, and BigQuery. Most are one-click OAuth. For internal tools, you point Devin at your own API endpoint.
Once connected, Devin creates PRs, responds to issues, posts updates in Slack threads, queries your databases, and pulls context from any connected tool, all without per-session setup.
To set it up: Go to Settings > Integrations for native tools, or the MCP Marketplace for everything else.
When someone figures out the best way to test a frontend change, investigate a production error, or deploy to staging, that workflow should be available to everyone else on the team immediately.
Devin has two mechanisms for this: Skills and Playbooks.
Skills are SKILL.md files committed to your repos. They define reusable procedures like testing before a PR, deploying to staging, investigating a codebase, and scaffolding a service. They follow the open Agent Skills standard, so the same files work across multiple AI tools.
Place them at .agents/skills/<skill-name>/SKILL.md. Devin's backend indexes skill files across all connected repositories, so your team has a shared catalog of procedures. Devin matches skills to the task at hand, so repo-specific skills only activate when working in that repo.
When someone asks Devin to fix a bug in that frontend repo, it activates test-before-pr before opening the PR. It won't fire when working on a different repo.
Skills support $ARGUMENTS for parameters, !`git branch --show-current` for live context injection, and allowed-tools to restrict Devin to read-only operations for investigation tasks.
Devin itself also suggests creating skills. After it learns something about your setup during a session, it proposes a SKILL.md and gives you a Create PR button. Every skill committed is immediately available to everyone on the team.
Playbooks are org-wide reusable prompt templates. They live in the Devin web app, are shared across your organization, and can be attached to any session.
Playbooks have macros, short identifiers like !investigate, so anyone can attach one by typing the macro name when starting a session. Enterprise customers can push playbooks across all organizations.
To set it up: Go to Settings > Playbooks. For skills, commit SKILL.md files to your repos.
Your team has conventions and context that determine whether AI output is generic or useful. "MRR is stored in cents, not dollars." "Never deploy on Fridays after 3pm." "Active user means at least one event in the past 30 days." When the AI knows these things, every task gets better output.
Devin's Knowledge system stores this persistently. Tips, instructions, and context persist across all sessions, and Devin recalls relevant knowledge based on what it's working on.
You create knowledge in Settings > Knowledge with a trigger and content:
- Trigger: "deploying to production"
- Content: "Always run the full E2E suite against staging before deploying. Use the
deploy-checklistrunbook in Notion. Never deploy on Fridays after 3pm."
Knowledge is scoped at three levels:
- Organization: visible to all members
- Enterprise: shared across all organizations in your company
- Pinned to repos: always active when Devin works in a specific repo
Devin suggests knowledge automatically. When you give feedback in a session, it proposes a knowledge item to remember for next time.
You can organize knowledge into folders, bulk enable/disable sets, and use macros (!deploy-checklist) for quick reference.
To set it up: Go to Settings > Knowledge. Or work with Devin and accept the suggestions it proposes.
Daily health digests, weekly dependency updates, nightly smoke tests, Monday morning metrics reports. Recurring work that should run without someone remembering to start it.
Devin's Scheduled Sessions run on cron:
- Recurring: hourly, daily, weekly, or custom expressions like
0 9 * * 1-5 - One-time: runs once at a specific date and time, then auto-disables
- Notifications: email and Slack channel alerts
- Playbook attachment: attach a playbook so every run follows the same procedure
Examples:
- Every morning at 8am, query monitoring tools for error rates and latency, post a health digest to Slack
- Every week, check for outdated dependencies, run the test suite against updates, open grouped PRs by severity
- Every night, run E2E smoke tests across core user flows, report pass/fail to
#engineering - Weekly, scan for recurring error patterns in logs and file tickets for anything crossing a threshold
- Every Monday, have DANA pull key business metrics from your database, compare week-over-week trends, and post a summary with charts to your team's Slack channel
For large tasks, Devin spins up Managed Devins, parallel child sessions each running in its own VM. A coordinator session scopes the work, monitors progress, resolves conflicts, and compiles results.
To set it up: Go to Settings > Schedules, create a schedule, write a prompt, set the cron, and optionally attach a playbook and Slack channel.
The people responding to customer escalations and triaging production alerts are in Slack. The AI should be there too.
Devin works natively in Slack. Tag @Devin in any channel and it starts a session in-thread with full access to your integrations, knowledge, skills, and playbooks.
Inline keywords:
| Keyword | What it does |
|---|---|
!ask |
Quick codebase answer without a full session |
!deep |
Deeper research answer using advanced search |
!dana |
Starts a Data Analyst session for database queries and visualizations |
!fast |
Starts in Fast Mode for simpler tasks |
![macro] |
Attaches a playbook by its macro name |
A support engineer types @Devin !investigate in a channel. Devin launches a session with the !investigate playbook, pulls context from Sentry via MCP, traces the error, and posts findings in the thread.
To set it up: Go to Settings > Integrations > Slack, connect, install the Slack app, and link user accounts.
Each skill committed, each knowledge item saved, each playbook refined makes every future session better for every person on the team. One engineer writes a deployment procedure, commits it, and every session from that point forward follows it.
Devin has multiple layers of shared configuration that do this, each scoped differently:
-
AGENTS.mdis committed to repo root and read before Devin starts coding. Setup commands, code style, testing guidelines, project structure. -
Skills are
SKILL.mdfiles in repos, auto-discovered. One engineer writes a procedure, commits it, every future session uses it. -
Knowledge is org-wide context that persists across sessions.
-
Playbooks are org-wide reusable prompts with macros.
-
Enterprise Knowledge and Playbooks propagate standards across all organizations in a company.
-
Golden Snapshots (Enterprise) are machine templates at the enterprise level inherited by every org. Repos, tools, dependencies, environment variables, shell config.
Each layer is additive. A committed skill, a saved knowledge item, or a refined playbook is immediately available to everyone.
Everything described in this post is configuration, not code. One person on your team can set up integrations, write the first batch of skills and playbooks, populate knowledge, and wire up scheduled sessions in a few days. There's no infrastructure to build, no internal tooling team required, and no ongoing maintenance beyond refining skills and knowledge as your team uses them.
This is also a real service opportunity. If you're a consultant or agency, you can stand up this entire stack for a client: connect their tools, write skills tailored to their workflows, configure their knowledge base, set up scheduled automations, and hand them a working system. Every piece of it is built into Devin.