Every skill your team needs. One conversation away.
dev-agents ships with curated skills that work from day one. Ask questions in Slack. Get code-level answers. No training, no configuration, no new tools.
Just $99/mo. Unlimited users.
Built-in skills for every dev team need.
Ready on day one. Build custom skills for anything else.
Code Research
"Where does the billing retry logic live?" - answered from actual code, no developer interrupted.
"How does the authentication flow work?"
Test Plans
Nobody wants to write test cases by hand. Get a structured test plan from any PR in 60 seconds.
"Create a test plan for this Jira ticket"
Bug Triage
"Can't repro" is over. Get the root cause, the file, the line - triaged before standup.
"Customer reports a 500 on checkout - where is the bug?"
Release Notes
Stop shipping "bug fixes and improvements." Get real changelogs your PM can send to customers.
"Generate release notes for v2.4"
IaC Review & Security Audit
That security group open to the world? Caught at PR time, not post-breach. Every Terraform and K8s change reviewed.
"Audit the Terraform changes in MR !87"
PRD & Spec Generation
Specs that stay current with the code - not a document graveyard nobody reads.
"Draft a PRD for adding SSO to the customer portal"
Sprint Health
Know where things actually stand with just one Slack message.
"Are there any blocked PRs or stale branches this sprint?"
RFP & Proposal Response
Stop hunting down SMEs and copy-pasting from last time. Answers pulled from your docs and code automatically.
"Draft answers for the security section of this RFP"
Codebase-to-Copy
Marketing asks "what does this feature actually do?" and gets accurate copy - no developer handoff needed.
"Write launch copy for the new API rate-limiting feature"
Curated skills are included on all paid plans. Codeligence tunes and optimizes them continuously.
Ask your codebase anything.
Explore architecture, trace logic, and understand decisions - through conversation in Slack.
New team members need context. Product owners need to understand impact. Support needs to trace customer issues. DevOps needs to know how systems connect.
The Code Research skill lets anyone on your team ask questions about the codebase and get answers in plain language - right in Slack or Teams. No IDE required. No developer interrupted.
Key Benefits
- Anyone on the team can explore the codebase
- Answers in plain language, not code dumps
- No IDE access or technical setup required
Used by: Developers, Product Owners, DevOps, Support, New Hires
Example Prompts
"How does the authentication flow work?"
"Which services call the payment API?"
"What changed in the billing module since January?"
"Where is the retry logic for failed webhooks?"
Get root cause, not just a ticket.
Support asks about a bug and gets a diagnosis with file:line references - no developer escalation required.
A customer reports an issue. Support opens the ticket. Normally, the next step is escalating to engineering and waiting hours - or days - for someone to trace the problem.
The Bug Triage skill takes a bug description, searches the codebase, and returns a root cause diagnosis with exact file and line references. Support engineers get technical context they can act on. Developers get pre-triaged issues with reproduction paths instead of vague descriptions.
Key Benefits
- Support resolves issues without escalating to engineering
- Bug reports arrive with file:line references, not guesswork
- Mean time to resolution drops because triage starts immediately
Used by: Support Engineers, QA Engineers, DevOps, On-Call Developers
Example Prompts
"Customer reports a 500 on checkout - where is the bug?"
"Triage this Sentry error and find the root cause"
"Why is the CSV export timing out for large datasets?"
"Trace this null pointer exception to the source"
Know exactly what to test.
Generate test plans from pull requests, tickets, or user stories - so QA never has to guess.
When a PR lands, someone needs to figure out what to test. Usually that means reading the code, tracing the changes, and hoping nothing gets missed.
The Test Plans skill reads the code changes and generates a structured test plan: what to test, what edge cases to cover, and what areas might break. QA gets a starting point in minutes instead of hours.
Key Benefits
- Test coverage that actually matches the code change
- Edge cases surfaced before they become bugs in production
- QA teams start testing faster, with more confidence
Used by: QA Engineers, QA Leads, Product Owners, Developers
Example Prompts
"Create a test plan for this Jira ticket"
"What should I test for PR #218?"
"What edge cases should we cover for the new checkout flow?"
Ship changelogs without the busywork.
Auto-generated release notes from commits and pull requests. Ready to share with your team or your customers.
Release day arrives. Someone scrambles to compile what changed, cross-reference PRs with tickets, and write something readable. It takes hours. It's always behind.
The Release Notes skill generates changelogs directly from your commits and PRs. Internal format for the team. Customer-facing format for the product update. Both created from a single prompt.
Key Benefits
- Release notes that are accurate because they come from the code
- Two formats: internal (technical) and external (customer-facing)
- No more scrambling on release day
Used by: Product Owners, Engineering Managers, Developer Relations
Example Prompts
"Generate release notes for v2.4"
"What shipped in the last two weeks?"
"Create a customer-facing changelog for this sprint"
Catch misconfigurations before they hit production.
Automated review of Terraform, Helm, and Kubernetes manifests on every merge request - security and compliance checked in seconds.
Infrastructure-as-code changes ship fast. But a misconfigured security group, an open S3 bucket, or a missing resource limit can take down production or expose customer data.
The IaC Review & Security Audit skill scans every merge request that touches Terraform, Helm charts, or Kubernetes manifests. It flags misconfigurations, policy violations, and drift from best practices - with specific remediation steps. DevOps and SREs get a second pair of eyes on every infrastructure change, without waiting for a manual review.
Key Benefits
- Security misconfigurations caught before they reach production
- Every infrastructure MR reviewed automatically - no bottleneck
- Compliance checks that run consistently, not when someone remembers
Used by: DevOps, SREs, Security Engineers, Platform Teams
Example Prompts
"Audit the Terraform changes in MR !87"
"Are there any open security groups in this Helm chart?"
"Check this K8s manifest for missing resource limits"
"Does this infrastructure change comply with our security policy?"
Turn ideas into structured specs - fast.
Reads your codebase, interviews the product owner, and outputs a complete PRD with acceptance criteria and technical constraints.
Writing a PRD from scratch takes days. Understanding what the system already does, what constraints exist, and what edge cases matter - that research alone eats most of the time.
The PRD & Spec Generation skill reads your codebase to understand the current architecture, then guides stakeholders through a structured interview. The output is a complete requirements document: user stories, acceptance criteria, technical constraints, and open questions - ready for the team to review, not rewrite.
Key Benefits
- PRDs grounded in the actual codebase, not assumptions
- Specs that include edge cases and constraints from day one
- Product owners ship requirements in hours, not days
Used by: Product Owners, Engineering Managers, Tech Leads, Solution Architects
Example Prompts
"Draft a PRD for adding SSO to the customer portal"
"Generate a spec for the new webhook retry system"
"What are the technical constraints for adding multi-tenancy?"
Spot friction before it slows you down.
Monitor sprint progress, detect blockers, and surface recurring patterns - so your team stays on track without micromanagement.
Standups surface problems too late. Retros repeat the same themes. Blockers hide in stale PRs, stuck reviews, and branches nobody merged.
The Sprint Health skill continuously monitors your sprint signals - open PRs, review bottlenecks, long-lived branches, and unresolved blockers. It flags risks in Slack before they derail the sprint. Over time, it recognizes recurring patterns across sprints and surfaces improvement suggestions your team can actually act on.
Key Benefits
- Blockers and stale PRs flagged before they derail the sprint
- Recurring friction patterns surfaced across sprints automatically
- Sprint visibility for the whole team - without extra status meetings
Used by: Scrum Masters, Engineering Managers, Tech Leads, Product Owners
Example Prompts
"How is our current sprint looking?"
"Are there any PRs that have been waiting for review for more than 2 days?"
"What patterns keep recurring in our last 3 sprints?"
"Which areas of the codebase are creating the most review bottlenecks?"
Fill RFPs in minutes, not weeks.
Pulls accurate answers from your docs and codebase to auto-fill RFPs, security questionnaires, and vendor assessments.
An RFP arrives with 200 questions. Half are about your security posture, architecture, and compliance. The answers exist - scattered across wikis, docs, and code - but finding and compiling them takes weeks.
The RFP & Proposal Response skill searches your codebase and documentation to draft accurate answers for each question. Security questionnaires, vendor assessments, technical due diligence - all sourced from what your team actually built, not what someone remembers. Sales and pre-sales prep in minutes instead of days.
Key Benefits
- RFP responses sourced from real code and docs, not memory
- Security questionnaires filled in minutes instead of weeks
- Sales cycles move faster because proposals are always ready
Used by: Sales, Pre-Sales, Solution Architects, Security Engineers
Example Prompts
"Draft answers for the security section of this RFP"
"Fill out the architecture questions in this vendor assessment"
"What's our current authentication and encryption approach?"
"Compile compliance answers for this security questionnaire"
Turn features into marketing copy.
Reads your source code, extracts real features, and generates landing page copy, launch emails, and product descriptions.
Marketing needs to write about the product. But the feature details live in code, PRs, and Jira tickets that marketers don't have access to - or can't parse. So they wait for a developer to explain, and the launch slips.
The Codebase-to-Copy skill reads your source code and recent changes, extracts what was actually built, and generates ready-to-use marketing copy. Landing page sections, feature descriptions, launch emails, changelog summaries - all grounded in the real product, not guesswork.
Key Benefits
- Marketing copy that describes what was actually built
- Launch emails and feature pages ready in minutes, not days
- No developer time spent explaining features to marketing
Used by: Marketing, Product Marketing, Developer Relations, Product Owners
Example Prompts
"Write launch copy for the new API rate-limiting feature"
"Generate a product update email from last sprint's changes"
"Create landing page copy for the new SSO integration"
"Summarize what shipped this month for the marketing team"
Your workflows. Your skills.
Build custom skills for any workflow your team needs. No code required.
Built-in skills cover the most common dev team needs. But every team has workflows that are unique - migration checklists, dependency audits, architecture decision records, API documentation, sprint retrospectives.
On all paid plans, we help you build custom skills using plain language. Define what the skill does, what context it needs, and how it should respond. Your team uses it the same way - just ask in Slack.
Examples teams have built
- + Migration assistant for legacy code transitions
- + API documentation generator from code comments
- + Dependency update reviewer with risk assessment
- + Security vulnerability scanner for specific frameworks
- + Sprint retrospective summarizer from Slack threads
One agent. Your whole team.
Every role gets code-level answers - without learning to code.
QA Engineers
Generate test plans from PRs and stories. Get edge cases surfaced before you start testing.
"Create a test plan for PR #218"
Product Owners
Research features, trace changes, and refine stories - without waiting for a developer to free up.
"What's the impact of removing the legacy billing module?"
DevOps & SREs
Analyze incidents, trace errors, and understand deployment changes through conversation.
"What changed in the last deployment that could cause this timeout?"
Support Engineers
Trace customer issues to code. Get technical context for bug reports without escalating to engineering.
"Why is customer #4521 getting a 403 on the dashboard?"
Engineering Managers
Generate release notes, track what shipped, and get visibility into code changes without reading every PR.
"What did the team ship this week?"
Sales & Pre-Sales
Fill RFPs and security questionnaires with accurate, codebase-sourced answers. Prep for demos with real feature details.
"Draft answers for the security section of this RFP"
Used daily by a 50-person engineering team.
"Developers wouldn't realize they were impacting shared components. Codeligence built an agent that takes our pull requests and does a fantastic job identifying every component that's touched, including UI impact changes and testing notes."
CTO
Behavioral Health Software Company - 50 users, daily multi-use across the organization
Get started with dev-agents today.
Curated skills. Your whole team. Running in minutes.