## Key Considerations: - Be specific about requirements - Provide context about your project - Specify coding standards and patterns - Give strong educational and experience background - Develop strong need to document well - Give agent artistic style

## Effective Prompts:

Hi [agent], my name is [your name]. [Build agent worker profile] [build agent educational background: degrees and certs] [minor technical skills][build agent experience: github] 

[build agent need to document well and visually]
[Initial task][give agent resources for task]
[build agent visual style: give examples such as images, websites or repos]
[build agent art style: give it context such as 'whimsical']

Stop and let me know once you've completed your thorough research and are ready to begin the project.

## Documentation Types: - Code comments - README files - API documentation - User guides

## Effective Prompts:

Create documentation for this [code/function/API].
Include purpose, parameters, return values, examples,
and potential edge cases.

You're also amazing at creating easily digestible deep technical documentation for your projects and favor using mermaid charts for visual representation.

## Best Practices: - Focus on one improvement at a time - Verify each change before moving to the next - Update documentation with each significant change

## Example Prompts:

-I'm noticing our mermaid diagrams aren't working. Can you see if you can resolve this?

-Here's a forum where they discuss the issue and resolved it. Take a look to find a solution. Don't just view the webpage. Find a more creative way to scrub the website.
https://github.com/orgs/marp-team/discussions/207#discussioncomment-1594903

-Lets move on past mermaid diagrams. Lets not use them for this presentation

-Instead lets create a blog post along with our presentation so that we can preserve our mermaid diagrams. Look at /blog/_posts/2025-04-21-deep-learning-for-malware-analysis.md for an example of how to write it.

-Great, now lets go back to our presentation and remove the mermaid diagrams and instead generate place holder content. The placeholder content should be a prompt to give napkin.ai so that it can build the diagrams for us.

## Benefits: - Catch issues human reviewers might miss - Standardize review process - Educate developers on best practices

## Effective Prompts:

-Hi [agent], my name is [your name]. [Principle Engineer] [Masters in Software Engineering] [CSM Cert] [minor technical skills] [build agent experience: github] [build agent need to document well and visually]

Stop and let me know once you’ve completed your thorough research and are ready to begin the project.

-Review this code for potential issues, bugs, or improvements.
Check if this code follows [specific standards].

## Security Checks: - Input validation - Authentication/authorization issues - Data exposure risks - Dependency vulnerabilities

## Effective Prompts:

-Hi [agent], my name is [your name]. [Security Engineer] [Masters is Software Engineering] [CSSLP, CompTIA Security+ & CISSP Certs] [minor technical skills] [build agent experience: github] [build agent need to document well and visually]

Stop and let me know once you’ve completed your thorough research and are ready to begin the project.

-Analyze this code for security vulnerabilities.
How could this code be exploited?
Suggest security improvements for this implementation.

## Documentation Quality Checklist: - Accuracy - Completeness - Clarity - Examples - Troubleshooting guidance

## Effective Prompts:

-Hi [agent], my name is [your name]. [Technical Writer] [Masters in Software Engineering] [CSM, CISSP, CPCT (Certified Professional Technical Communicator) Certs] [Submitted to pubs like IEEE] [build agent experience: github] [build agent need to document well and visually]

Stop and let me know once you’ve completed your thorough research and are ready to begin the project.

-Update this documentation to reflect the changes made.
Expand this documentation to include [specific aspects].
Create a troubleshooting guide for this component.

## Testing Documentation Components: - Test scenarios - Expected outcomes - Edge cases - Test data requirements - Testing environment setup

## Effective Prompts:

-Hi [agent], my name is [your name]. [Technical Writer] [Masters in Software Engineering] [CSM, CISSP, CPCT (Certified Professional Technical Communicator), CSTE (Certified Software Tester), ISTQB Advanced Test Analyst Certs] [Submitted to pubs like IEEE] [build agent experience: github] [build agent need to document well and visually]

-Create test cases for this [function/component/feature].
Generate unit tests for this code.
What edge cases should be tested for this functionality?

## Continuous Improvement: - Add tests for discovered edge cases - Refine existing test cases - Document known limitations

## Effective Prompts: ``` Update these test cases based on the issues found. Generate additional test scenarios for [specific feature]. Create regression tests for the bugs that were fixed. ```

## Defect Resolution Process: - Understand the root cause - Implement fixes - Verify the fix - Update documentation - Add regression tests

## Effective Prompts: ``` Fix this bug: [description of issue]. Suggest a solution for this problem: [problem details]. Optimize this code that's causing [specific performance issue]. ```

Developer

Focus: Initial Build, AI Surprises, Docs Creation, Refinement, Code Review, Defects, Rubber Stamp & Yeet to Prod
Primary concern: Functionality and code quality
Uses AI for: Code generation, debugging, optimization

Security Analyst

Focus: Security Review, Defects, Rubber Stamp & Yeet to Prod
Primary concern: Identifying vulnerabilities
Uses AI for: Security analysis, threat modeling, compliance checking

Tester

Focus: Testing Docs Creation, Click-through Testing, Update Testing Docs, Defects
Primary concern: Finding bugs and edge cases
Uses AI for: Test case generation, regression testing

Designer

Focus: Initial Build, AI Surprises, Docs Creation, Refinement, Click-through Testing
Primary concern: User experience and accessibility
Uses AI for: UI patterns, accessibility compliance

### Documentation Roles - Developers: Code comments, API docs, architectural decisions - Security Analysts: Security guidelines, vulnerability mitigations - Testers: Test cases, bug reports, user scenarios - Designers: UI guidelines, accessibility requirements, user flows

### Benefits of Shared Documentation - Knowledge transfer between team members - Building AI knowledge base for future assistance - Consistent implementation across projects - Easier onboarding for new team members - Maintainable codebase with clear context - Reduced knowledge silos and dependencies

Accessibility

AI can help ensure accessibility standards are met
Generates accessible code patterns
Identifies accessibility issues

Thinking Bigger

Enables tackling more ambitious projects
Helps understand complex patterns
Facilitates learning new technologies

Freeing Spoons

Reduces cognitive load on repetitive tasks
Allows focus on creative problem-solving
Handles boilerplate code generation

Effective Communication

Teaches how to articulate requirements clearly
Improves technical communication skills
Encourages precise specification

## API Costs - Consider cost per token for AI services - Strategies to optimize costs: - Refine prompts to be concise - Batch similar requests - Cache common responses - Use smaller models for simpler tasks

## Cost vs. Value - Time saved × Developer hourly rate - Reduced bugs and technical debt - Faster time to market - Learning and skill development

## Key Points: - AI-generated code requires the same scrutiny as any other code - You remain responsible for understanding and maintaining your codebase

- AI is a tool, not a replacement for developer judgment - Verification and testing are still essential

Understand Implementation

Don't blindly copy AI suggestions
Ask AI to explain complex code
Review code for security implications

Verify and Test

Test all AI-generated code
Verify edge cases
Implement automated testing

Maintain Standards

Ensure AI output follows your standards
Refactor as needed
Keep code consistent with existing patterns

Continuous Learning

Use AI as a learning tool
Understand the patterns it suggests
Share insights with your team

AI-assisted Development

Streamlines the development process
Enhances productivity across roles
Requires responsible use and verification
Doesn't replace human judgment and expertise

Key Takeaways

The quality of AI output depends on your input
Documentation remains everyone's responsibility
AI is a tool that amplifies your capabilities
Vibe coding is legitimate when done responsibly

Overview