Complete Evernote integration skill pack with 24 skills covering note management, notebooks, tags, search, and productivity workflows. Flagship tier vendor pack.

24 Skills

MIT License

Free Pricing

Installation

Open Claude Code and run this command:

/plugin install evernote-pack@claude-code-plugins-plus

Use --global to install for all projects, or --project for current project only.

Skills (24)

evernote-ci-integration SKILL.md View full skill →

Configure CI/CD pipelines for Evernote integrations.

ReadWriteEditBash(npm:*)Grep

Evernote CI Integration

Overview

Configure continuous integration pipelines for Evernote integrations with mock-based unit tests, sandbox-based integration tests, credential management, and deployment workflows.

Prerequisites

Git repository with Evernote integration code
CI/CD platform (GitHub Actions, GitLab CI, etc.)
Test framework (Jest, Vitest, or Mocha)
Sandbox API credentials for integration tests

Instructions

Step 1: GitHub Actions Workflow

Create a workflow that runs unit tests on every PR and integration tests on merges to main. Store sandbox credentials as GitHub Actions secrets.


# .github/workflows/evernote-ci.yml
name: Evernote CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '20' }
      - run: npm ci
      - run: npm test
      - name: Integration tests
        if: github.ref == 'refs/heads/main'
        env:
          EVERNOTE_DEV_TOKEN: ${{ secrets.EVERNOTE_SANDBOX_TOKEN }}
          EVERNOTE_SANDBOX: 'true'
        run: npm run test:integration

Step 2: Mock Evernote Client for Unit Tests

Create a mock NoteStore that returns predictable data without hitting the API. Mock createNote, getNote, findNotesMetadata, listNotebooks, and listTags.


class MockNoteStore {
  constructor() {
    this.notes = new Map();
    this.notebooks = [{ guid: 'nb-1', name: 'Default', defaultNotebook: true }];
  }

  async createNote(note) {
    const guid = `note-${Date.now()}`;
    const created = { ...note, guid, created: Date.now(), updated: Date.now() };
    this.notes.set(guid, created);
    return created;
  }

  async getNote(guid, withContent) {
    const note = this.notes.get(guid);
    if (!note) throw { identifier: 'Note.guid', key: guid };
    return withContent ? note : { ...note, content: undefined };
  }

  async listNotebooks() { return this.notebooks; }
}

Step 3: Unit and Integration Test Examples

Write unit tests against the mock client (fast, no credentials needed). Write integration tests against the sandbox (slow, needs EVERNOTEDEVTOKEN). Tag integration tests so they can run separately.

Step 4: Secrets Management

Store EVERNOTECONSUMERKEY, EVERNOTECONSUMERSECRET, and EVERNOTEDEVTOKEN as repository secrets. Never log or echo secret values. Use environment-specific secret names for staging vs production.

For the full CI workflow, mock client, test examples, and deployment pipeline, see Implementation Guide.

Ou

evernote-common-errors SKILL.md View full skill →

Diagnose and fix common Evernote API errors.

ReadWriteEditGrep

Evernote Common Errors

Overview

Comprehensive guide to diagnosing and resolving Evernote API errors. Evernote uses three exception types: EDAMUserException (client errors), EDAMSystemException (server/rate limit errors), and EDAMNotFoundException (invalid GUIDs).

Prerequisites

Basic Evernote SDK setup
Understanding of Evernote data model

Instructions

EDAMUserException Error Codes

Code	Name	Cause	Fix
1	`BADDATAFORMAT`	Invalid ENML, missing DOCTYPE	Validate ENML before sending; check for forbidden elements
2	`DATA_REQUIRED`	Missing required field (title, content)	Ensure `note.title` and `note.content` are set
3	`PERMISSION_DENIED`	API key lacks permissions	Request additional permissions from Evernote
4	`INVALID_AUTH`	Invalid or revoked token	Re-authenticate user via OAuth
5	`AUTH_EXPIRED`	Token past expiration date	Check `edam_expires`, refresh token
6	`LIMIT_REACHED`	Account limit exceeded (250 notebooks)	Clean up resources before creating new ones
7	`QUOTA_REACHED`	Monthly upload quota exceeded	Check `user.accounting.remaining`

ENML Validation

The most common error is BADDATAFORMAT from invalid ENML. Validate before sending:


function validateENML(content) {
  const errors = [];
  if (!content.includes('<?xml version="1.0"')) errors.push('Missing XML declaration');
  if (!content.includes('<!DOCTYPE en-note')) errors.push('Missing DOCTYPE');
  if (!content.includes('<en-note>')) errors.push('Missing <en-note> root');

  const forbidden = [/<script/i, /<form/i, /<iframe/i, /<input/i];
  forbidden.forEach(p => { if (p.test(content)) errors.push(`Forbidden: ${p.source}`); });

  if (/\s(class|id|onclick)=/i.test(content)) errors.push('Forbidden attributes');
  return { valid: errors.length === 0, errors };
}

EDAMSystemException Handling

Rate limit errors include rateLimitDuration (seconds to wait). Maintenance errors should be retried with progressive backoff.


async function withRetry(operation, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await operation();
    } catch (error) {
      if (error.rateLimitDu


                
                  
                  
                  evernote-core-workflow-a
                  SKILL.md
                  View full skill →
                
                
                  Execute Evernote primary workflow: Note Creation and Management.
                  
                      ReadWriteEditBash(npm:*)Grep
                    
                
                
                  Evernote Core Workflow A: Note Creation & Management
Overview
Primary workflow for creating, organizing, and managing notes in Evernote. Covers CRUD operations, ENML formatting, notebook organization, and tag management.
Prerequisites

Completed evernote-install-auth setup
Understanding of ENML format
Valid access token configured

Instructions
Step 1: Note Creation Service
Build a NoteService class that wraps NoteStore operations. Key methods: createNote() with ENML wrapping, createTextNote() for plain text, createChecklistNote() for  items. Always sanitize titles (max 255 chars, no newlines) and wrap content in the required ENML envelope.

// Wrap raw HTML in required ENML envelope
function wrapInENML(content) {
  return `<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">
<en-note>${content}</en-note>`;
}

const note = new Evernote.Types.Note();
note.title = 'Meeting Notes';
note.content = wrapInENML('<p>Discussion points...</p>');
note.tagNames = ['meeting', 'team'];
const created = await noteStore.createNote(note);

Step 2: Note Retrieval and Reading
Use getNote(guid, withContent, withResources, withRecognition, withAltData) to control response size. Extract plain text from ENML by stripping tags. Check for uncompleted todos with /.

Step 3: Note Updates
Update notes by fetching metadata, modifying fields, and calling noteStore.updateNote(). Append content by inserting before the closing  tag. Add tags via note.tagNames array. Move notes between notebooks by changing note.notebookGuid.
Step 4: Note Organization
Manage notebooks with listNotebooks(), createNotebook(), and getDefaultNotebook(). Use notebook.stack to group notebooks into stacks. Implement ensureNotebook(name) to find-or-create by name.
Step 5: Complete Workflow Example
See Implementation Guide for the full NoteService, NotebookService, and a combined workflow that creates meeting notes with checklists, appends content, and toggles todos.
Output

NoteService class with create, read, update, and delete operations
ENML content formatting and validation helpers
NotebookService for notebook CRUD and stack organization
Tag management (add, remove, find-or-create)
Checklist note support with  elements


                
                  
                  
                  evernote-core-workflow-b
                  SKILL.md
                  View full skill →
                
                
                  Execute Evernote secondary workflow: Search and Retrieval.
                  
                      ReadWriteEditBash(npm:*)Grep
                    
                
                
                  Evernote Core Workflow B: Search & Retrieval
Overview
Comprehensive search and retrieval workflow for Evernote, including search grammar, filters, pagination, related notes discovery, and result enrichment with notebook/tag names.
Prerequisites

Completed evernote-install-auth setup
Understanding of Evernote search grammar
Valid access token configured

Instructions
Step 1: Search Service Foundation
Build a SearchService wrapping findNotesMetadata(). Use NoteFilter for query terms, sort order, and notebook scope. Use NotesMetadataResultSpec to control which metadata fields are returned (title, dates, tags, notebook GUID).

const filter = new Evernote.NoteStore.NoteFilter({
  words: 'tag:urgent notebook:"Work"',
  ascending: false,
  order: Evernote.Types.NoteSortOrder.UPDATED
});

const spec = new Evernote.NoteStore.NotesMetadataResultSpec({
  includeTitle: true, includeUpdated: true,
  includeTagGuids: true, includeNotebookGuid: true
});

const result = await noteStore.findNotesMetadata(filter, 0, 50, spec);

Step 2: Advanced Search Grammar Builder
Implement a fluent QueryBuilder class that chains operators: notebook("Work"), tag("urgent"), intitle("meeting"), createdAfter(date), hasUncompletedTodos(), hasAttachments(). Call .build() to produce the query string. Use any: prefix for OR logic.

const query = new QueryBuilder()
  .notebook('Work')
  .tag('urgent')
  .lastNDays(7)
  .hasUncompletedTodos()
  .build();
// Result: 'notebook:"Work" tag:"urgent" created:day-7 todo:false'

Step 3: Paginated Search Results
Use an async generator to iterate through large result sets page by page. Track offset and compare against totalNotes to determine when to stop. Default page size of 50-100 balances API calls versus response size.
Step 4: Related Notes Discovery
Call noteStore.findRelated() with a RelatedQuery (by note GUID or plain text) and RelatedResultSpec to discover related notes, notebooks, and tags.
Step 5: Search Result Enrichment
Cache notebook and tag lookups, then map GUIDs to human-readable names. Return enriched results with notebookName, tags[], created, and updated fields.
For the full SearchService, QueryBuilder, pagination, and enrichment implementations, see Implementation Guide.
Search Grammar Quick Reference

Operator
                
              
                
                  
                  
                  evernote-cost-tuning
                  SKILL.md
                  View full skill →
                
                
                  Optimize Evernote integration costs and resource usage.
                  
                      ReadWriteEditGrep
                    
                
                
                  Evernote Cost Tuning
Overview
Optimize resource usage and manage costs in Evernote integrations, focusing on monthly upload quotas, storage efficiency, image compression, and account limit monitoring.
Prerequisites

Understanding of Evernote account tiers (Basic: 60MB/mo, Premium: 10GB/mo, Business: 20GB/mo)
Access to user quota information via user.accounting
Monitoring infrastructure for alerts

Instructions
Step 1: Quota Monitoring
Query userStore.getUser() to access user.accounting which contains uploadLimit, uploaded, and uploadLimitEnd. Calculate remaining quota and percentage used.

async function getQuotaStatus(userStore) {
  const user = await userStore.getUser();
  const { uploadLimit, uploaded, uploadLimitEnd } = user.accounting;
  return {
    totalMB: Math.round(uploadLimit / 1024 / 1024),
    usedMB: Math.round(uploaded / 1024 / 1024),
    remainingMB: Math.round((uploadLimit - uploaded) / 1024 / 1024),
    percentUsed: Math.round((uploaded / uploadLimit) * 100),
    resetsAt: new Date(uploadLimitEnd)
  };
}

Step 2: Resource Optimization
Compress images before attaching to notes. Resize large images to a maximum dimension (e.g., 1920px). Convert PNG screenshots to JPEG for smaller file sizes. Skip attaching files that exceed the single-note size limit (25MB for Basic, 200MB for Premium).

function estimateNoteSize(content, resources = []) {
  const contentBytes = Buffer.byteLength(content, 'utf8');
  const resourceBytes = resources.reduce((sum, r) => sum + r.data.size, 0);
  return contentBytes + resourceBytes;
}

function canUpload(noteSize, remainingQuota) {
  return noteSize < remainingQuota;
}

Step 3: Efficient Note Creation
Check quota before creating notes with large attachments. Use findNotesMetadata() for read operations (zero upload cost). Batch small notes into single notes where appropriate.
Step 4: Storage Cleanup
Find large notes consuming quota. List notes sorted by content length to identify optimization candidates. Remove unused resources and delete notes in trash to reclaim space.
Step 5: Quota Alerts
Send alerts when upload usage exceeds thresholds (e.g., 75%, 90%, 95%). Log quota status after each upload operation for trend analysis.
For the complete quota monitor, image optimizer, cleanup utilities, and alert system, see Implementation Guide.
Account Limits Reference

Limit
Basic
Premium
Business


Monthly upload
60 MB
10 GB
20 GB/user


Single note size
25 MB
                
              
                
                  
                  
                  evernote-data-handling
                  SKILL.md
                  View full skill →
                
                
                  Best practices for handling Evernote data.
                  
                      ReadWriteEditGrep
                    
                
                
                  Evernote Data Handling
Overview
Best practices for handling Evernote data including ENML content processing, attachment management, local database sync, and ENEX export/import.
Prerequisites

Understanding of Evernote data model (Notes, Notebooks, Tags, Resources)
Database for local storage (SQLite, PostgreSQL, etc.)
File storage for attachments

Instructions
Step 1: Data Schema Design
Design a local database schema that mirrors Evernote's data model. Key tables: notes (guid, title, content, notebookGuid, created, updated, USN), notebooks (guid, name, stack), tags (guid, name), resources (guid, noteGuid, mime, hash, size). Track Update Sequence Numbers (USN) for incremental sync.

CREATE TABLE notes (
  guid TEXT PRIMARY KEY,
  title TEXT NOT NULL,
  content TEXT,
  notebook_guid TEXT REFERENCES notebooks(guid),
  created BIGINT,
  updated BIGINT,
  usn INTEGER DEFAULT 0
);

Step 2: ENML Content Processing
Parse ENML to extract plain text (strip tags), convert to HTML (replace  with , resolve  to / tags), or convert to Markdown. Validate ENML before sending to the API by checking for required declarations and forbidden elements.


function enmlToPlainText(enml) {
  return enml
    .replace(/<\?xml[^>]*\?>/g, '')
    .replace(/<!DOCTYPE[^>]*>/g, '')
    .replace(/<[^>]+>/g, ' ')
    .replace(/\s+/g, ' ')
    .trim();
}

Step 3: Resource (Attachment) Handling
Download resources via noteStore.getResource(guid, withData, ...). Store binary data locally with the MD5 hash as filename. Track MIME types for proper content-type serving. Compute hashes for integrity verification.
Step 4: Sync Data Manager
Implement incremental sync using getSyncState() to get the current server USN, then getSyncChunk() to fetch changes since your last sync. Process chunks in order: notebooks first, then tags, then notes, then resources.

const syncState = await noteStore.getSyncState();
if (syncState.updateCount > lastSyncUSN) {
  const chunk = await noteStore.getSyncChunk(lastSyncUSN, 100, true);
  // Process chunk.notebooks, chunk.tags, chunk.notes, chunk.resources
}

Step 5: Data Export
Export notes to ENEX (Evernote's XML export format), JSON, or Markdown. ENEX preserves the full note structure including resources and is compatible with Evernote import.
For the complete data schema, sync manager, ENML processor, and export implementations, see Implementation Guide.
Output

                
              

                
                  
                  
                  evernote-debug-bundle
                  SKILL.md
                  View full skill →
                
                
                  Debug Evernote API issues with diagnostic tools and techniques.
                  
                      ReadWriteEditBash(npm:*)Bash(node:*)Grep
                    
                
                
                  Evernote Debug Bundle
Current State
!node --version 2>/dev/null || echo 'N/A'
!python3 --version 2>/dev/null || echo 'N/A'
Overview
Comprehensive debugging toolkit for Evernote API integrations, including request/response logging, ENML validation with auto-fix, token inspection, and diagnostic CLI utilities.
Prerequisites

Evernote SDK installed
Node.js environment
Understanding of common Evernote errors (see evernote-common-errors)

Instructions
Step 1: Debug Logger
Create a logger that captures API method names, arguments (with token redaction), response times, and error details. Write to both console and file for post-mortem analysis.

class EvernoteDebugLogger {
  constructor(logFile = 'evernote-debug.log') {
    this.logFile = logFile;
    this.requests = [];
  }

  logRequest(method, args, response, duration, error) {
    const entry = {
      timestamp: new Date().toISOString(),
      method,
      duration: `${duration}ms`,
      success: !error,
      error: error?.message || error?.errorCode
    };
    this.requests.push(entry);
    fs.appendFileSync(this.logFile, JSON.stringify(entry) + '\n');
  }
}

Step 2: Instrumented Client Wrapper
Wrap the NoteStore with a Proxy that automatically logs every API call, measures response time, and catches errors. This adds zero-config debugging to any existing integration.

function instrumentNoteStore(noteStore, logger) {
  return new Proxy(noteStore, {
    get(target, prop) {
      if (typeof target[prop] !== 'function') return target[prop];
      return async (...args) => {
        const start = Date.now();
        try {
          const result = await target[prop](...args);
          logger.logRequest(prop, args, result, Date.now() - start);
          return result;
        } catch (error) {
          logger.logRequest(prop, args, null, Date.now() - start, error);
          throw error;
        }
      };
    }
  });
}

Step 3: ENML Validator
Validate ENML content against the DTD rules: check for XML declaration, DOCTYPE,  root, forbidden elements, and unclosed tags. Optionally auto-fix common issues (add missing headers, close tags, strip forbidden elements).
Step 4: Token Inspector
Check token validity by calling userStore.getUser(). Report token owner, expiration date (edam_expires), account type, and remaining upload quota.
Step 5: Diagnostic CLI
Create a CLI script with commands: diagnose (run all checks), validate-enml  (validate ENML content), inspect-token (show token info), test-api (verify API connectivity).
For the full debug logger, instrumen
                
              

                
                  
                  
                  evernote-deploy-integration
                  SKILL.md
                  View full skill →
                
                
                  Deploy Evernote integrations to production environments.
                  
                      ReadWriteEditBash(npm:*)Grep
                    
                
                
                  Evernote Deploy Integration
Overview
Deploy Evernote integrations to production environments including Docker containers, AWS ECS/Lambda, Google Cloud Run, and Kubernetes, with proper secrets management and health checks.
Prerequisites

CI/CD pipeline configured (see evernote-ci-integration)
Production API credentials approved by Evernote
Cloud platform account (AWS, GCP, or Azure)
Docker installed for containerized deployments

Instructions
Step 1: Docker Deployment
Create a multi-stage Dockerfile that builds the app and produces a minimal production image. Set NODE_ENV=production and configure the Evernote SDK for production endpoints.

FROM node:20-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .
RUN npm run build

FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
ENV NODE_ENV=production EVERNOTE_SANDBOX=false
EXPOSE 3000
CMD ["node", "dist/index.js"]

Step 2: Google Cloud Run Deployment
Deploy the Docker image to Cloud Run with secrets mounted from Secret Manager. Cloud Run scales to zero when idle, making it cost-effective for webhook receivers.

gcloud run deploy evernote-app \
  --image gcr.io/PROJECT/evernote-app:latest \
  --set-secrets EVERNOTE_CONSUMER_KEY=evernote-key:latest \
  --set-secrets EVERNOTE_CONSUMER_SECRET=evernote-secret:latest \
  --allow-unauthenticated \
  --region us-central1

Step 3: AWS Lambda (Serverless)
Package the webhook handler as a Lambda function behind API Gateway. Use AWS Secrets Manager for credentials. Lambda is ideal for event-driven Evernote integrations (webhook processing, scheduled sync).
Step 4: Kubernetes Deployment
Create a Deployment with ConfigMap for non-secret settings and Kubernetes Secrets for API credentials. Include liveness and readiness probes that verify Evernote API connectivity.
Step 5: Deployment Verification
After deployment, verify: health check endpoint returns connected, a test note can be created and retrieved, webhook endpoint is reachable, and monitoring is reporting metrics.
For the full Dockerfile, Cloud Run config, Lambda handler, Kubernetes manifests, and deployment verification scripts, see Implementation Guide.
Output

Multi-stage Dockerfile for production builds
Google Cloud Run deployment with Secret Manager integration
AWS Lambda handler for serverless webhook processing
Kubernetes Deployment, Service, and Secret manifests
Deployment verification checklist and script

Error Handling

Error
Cause
                
              
                
                  
                  
                  evernote-enterprise-rbac
                  SKILL.md
                  View full skill →
                
                
                  Implement enterprise RBAC for Evernote integrations.
                  
                      ReadWriteEditGrep
                    
                
                
                  Evernote Enterprise RBAC
Overview
Implement role-based access control for Evernote integrations, including Evernote Business account handling, shared notebook permissions, multi-tenant architecture, and authorization middleware.
Prerequisites

Understanding of Evernote Business accounts and shared notebooks
Multi-tenant application architecture
Authentication/authorization infrastructure

Instructions
Step 1: Evernote Permission Model
Evernote has built-in sharing permissions for notebooks: READNOTEBOOK, MODIFYNOTEBOOKPLUSACTIVITY, READNOTEBOOKPLUSACTIVITY, GROUP, FULLACCESS. Map these to your application's role system.

const EvernotePermissions = {
  READ: 'READ_NOTEBOOK',
  WRITE: 'MODIFY_NOTEBOOK_PLUS_ACTIVITY',
  FULL: 'FULL_ACCESS'
};

const AppRoles = {
  viewer: [EvernotePermissions.READ],
  editor: [EvernotePermissions.READ, EvernotePermissions.WRITE],
  admin:  [EvernotePermissions.FULL]
};

Step 2: RBAC Service
Build a service that checks whether a user has the required permission for an operation. Query shared notebook privileges via noteStore.listSharedNotebooks() and getSharedNotebookByAuth().

class RBACService {
  async canAccess(userToken, notebookGuid, requiredPermission) {
    const noteStore = this.getAuthenticatedNoteStore(userToken);
    const sharedNotebooks = await noteStore.listSharedNotebooks();
    const shared = sharedNotebooks.find(sn => sn.notebookGuid === notebookGuid);
    if (!shared) return false;
    return this.hasPermission(shared.privilege, requiredPermission);
  }
}

Step 3: Authorization Middleware
Create Express middleware that validates the user's Evernote token and checks permissions before allowing access to protected routes.
Step 4: Evernote Business Integration
For Evernote Business accounts, use authenticateToBusiness() to get a business token. Business notebooks are shared across the organization. Use getBusinessNotebooks() to list them.
Step 5: Multi-Tenant Support
Isolate tenant data by scoping all Evernote operations to the tenant's access token. Never mix tokens between tenants. Store tenant-to-token mappings with encryption at rest.
For the full RBAC service, middleware, Business account integration, and multi-tenant architecture, see Implementation Guide.
Output

Evernote permission model mapped to application roles
RBACService class with permission checking
Express authorization middleware for protected routes
Evernote Business account integration

                
              

                
                  
                  
                  evernote-hello-world
                  SKILL.md
                  View full skill →
                
                
                  Create a minimal working Evernote example.
                  
                      ReadWriteEdit
                    
                
                
                  Evernote Hello World
Overview
Create your first Evernote note using the Cloud API, demonstrating ENML format and NoteStore operations.
Prerequisites

Completed evernote-install-auth setup
Valid access token (OAuth or Developer Token for sandbox)
Development environment ready

Instructions
Step 1: Create Entry File
Initialize an authenticated Evernote client. Use a Developer Token for sandbox or an OAuth access token for production.

// hello-evernote.js
const Evernote = require('evernote');

const client = new Evernote.Client({
  token: process.env.EVERNOTE_ACCESS_TOKEN,
  sandbox: true // false for production
});

Step 2: Understand ENML Format
Evernote uses ENML (Evernote Markup Language), a restricted XHTML subset. Every note must include the XML declaration, DOCTYPE, and  root element. Forbidden elements include 

      
      

          Related Plugins
          
            
                000-jeremy-content-consistency-validator
                Read-only validator that generates comprehensive discrepancy reports comparing messaging consistency across ANY HTML-based website (WordPress, Hugo, Next.js, React, Vue, static HTML, etc.), GitHub repositories, and local documentation. Detects mixed messaging without making changes.
              
                002-jeremy-yaml-master-agent
                Intelligent YAML validation, generation, and transformation agent with schema inference, linting, and format conversion capabilities
              
                003-jeremy-vertex-ai-media-master
                Comprehensive Google Vertex AI multimodal mastery for Jeremy - video processing (6+ hours), audio generation, image creation with Gemini 2.0/2.5 and Imagen 4. Marketing campaign automation, content generation, and media asset production.
              
                004-jeremy-google-cloud-agent-sdk
                Google Cloud Agent Development Kit (ADK) and Agent Starter Pack mastery - build containerized multi-agent systems with production-ready templates, deploy to Cloud Run/GKE/Agent Engine, RAG agents, ReAct agents, and multi-agent orchestration.
              
                agent-context-manager
                Automatically detects and loads AGENTS.md files to provide agent-specific instructions
              
                ai-commit-gen
                AI-powered commit message generator - analyzes your git diff and creates conventional commit messages instantly
              
          
        


      
      
          Tags
          
            evernotenotesnotebookstagssearchproductivityorganization
          
        
    

  


  

    

    
    
        
            
                Stay in the Loop
                
                    
                    
                    
                
                No spam. Unsubscribe anytime.
            

            
                
                    Product
                    
                        Explore
                        Skills
                        Cowork
                        Compare
                        Tools
                    
                
                
                    Resources
                    
                        Docs
                        Changelog
                        Collections
                        Playbooks
                        Research
                        Learning
                    
                
                
                    Company
                    
                        Community
                        Spotlight
                        GitHub
                    
                
                
                    Legal
                    
                        Privacy
                        Terms
                        Acceptable Use
                    
                
            

            
                Tons of Skills by Intent Solutions. Marine. Citadel Grad. 20 years ops → self-taught dev → AI architect.
                © 2026 Tons of Skills | Intent Solutions