Your First Day with AI: A Guide for Developers with No Experience

AI is a TOOL, and like any tool, its value comes from using it correctly.

When I first started using AI for software development, I had no idea where to begin. With my "try and see what happens" approach, I achieved quick results that radically changed how I develop software.

I'm writing this guide to help you avoid frustrations and leverage AI from day one. You don't need to be an expert in predictive models, statistics, machine learning, or linear algebra. If you can write code and have curiosity, you're already prepared to enhance your skills as a developer.

Photo by Matt Ridley on Unsplash

Setting Expectations

AI doesn't work miracles. It's not a technology that will complete your project with minimal intervention, regardless of how many perfectly orchestrated demos you see on social media. In real work environments, it needs guidance, control, and above all, context.

It's also not "just another NFT-like bubble" with no utility. AI is a TOOL, and like any tool, its value comes from using it correctly. To use it properly, you need to experiment continuously in various scenarios.

Who is this guide for?

This guide is for the curious, those passionate about learning, who try again when facing difficulties or know when to take a break to return later with renewed energy.

It's for developers who understand that code itself is not the end, but the means. Those who know that software development is much more than pressing keys in an IDE.

With this guide, you'll be able to:

• Accelerate your code development

• Understand complex code faster

• Solve difficult bugs more efficiently

• Learn new technologies effectively

• Improve communication with stakeholders and non-technical teams

Key Players in the Ecosystem

The most popular AI models and tools primarily belong to these companies:

• OpenAI: The pioneer that gave us ChatGPT

• Anthropic: Created by former OpenAI employees. Their model is Claude

• Microsoft: Provides tools like Copilot to use various models

• Google: With its Gemini model and associated tools

• Meta: The only major company with an open-source model called Llama

Prepare Your Experimentation Environment

You'll need access to two main types of tools: chats and code assistants.

Chats

These are interfaces for interacting with AI models without specific specialization:

Tool Strengths Ideal for ChatGPT Versatility General tasks, learning Grok Practical responses Code, debugging Claude Deep analysis Documentation, refactoring Gemini Concise responses Specific tasks

Code Assistants

These are specialized tools for planning, testing, and writing code:

• GitHub Copilot: VSCode extension with a generous free tier and student plans

• Google Code Assistant: Extension for VSCode and JetBrains IDEs

• Cursor: VSCode fork with integrated AI

• Windsurf: Similar to Cursor, with a limited free tier

Where do I start?

Take advantage of the free tiers of all chats. My recommendation:

• ChatGPT: General tasks like learning about topics, market research, text correction

• Grok: Like an intelligent colleague for defining software architectures

• Claude: Excellent for technical documentation and code review

• Gemini: Ideal for extensive contexts (documents, videos, complete repositories)

An effective strategy is to run the same prompt in at least two models to compare responses, then refine based on results. You can also ask one model to evaluate another's response, looking for improvements or identifying unconsidered aspects.

Prompts and Context

The key to getting useful responses is providing complete context. A vague prompt will generate generic or incorrect code; a detailed one will deliver solutions ready to implement.

How to Write Good Prompts

A language model is like an expert who has studied millions of texts and learned patterns. It doesn't search in a database but generates responses based on patterns learned during training.

The Power of "Act As" Prompts

A particularly effective type of prompt begins with "act as..." For example: "Act as a JavaScript developer with 10 years of experience in Node.js."

These prompts influence the response in several key ways:

1. Knowledge prioritization: The model will emphasize information relevant to that role, highlighting JavaScript patterns, Node.js ecosystem knowledge, and practices that an experienced developer would have.

2. Perspective shifting: It will adopt mental models and problem-solving approaches typical of experienced developers, focusing on efficient solutions, best practices, and potential pitfalls.

3. Terminology adjustment: It will use technical language and jargon appropriate for the specified level of expertise, responding with familiar language.

4. Experience simulation: It will incorporate practical insights that typically come from years of direct experience, such as troubleshooting patterns or architectural decisions.

5. Confidence calibration: Responses will reflect the appropriate confidence level for someone with that experience, neither over-explaining basic concepts nor omitting important context.

This technique is particularly effective because it leverages training in conversations where experts communicate differently than beginners. By specifying the role, you're activating relevant patterns in how the model structures and presents information.

The Importance of Complete Context

Beyond the role, providing detailed context is fundamental. For example, if you ask an AI (or even an expert human developer) "give me code to validate an email," regardless of their experience, they'll need more information:

• What programming language are you using?

• Is it for server, client, or another environment?

• Can you use any libraries?

• What level of complexity do you need in the validation?

• What should happen if the email is invalid?

• Are there specific security or compliance requirements?

AI models work best when they receive complete contextual information. You must provide all the necessary information to get the best possible response. It's better to provide too much information than too little.

Prompt Examples

Instead of: "Give me code to validate emails"

Simple example: "I need code to validate emails in JavaScript. It's for a simple contact form, and I only need to verify that it has the correct format before sending it."

Technical example (React): "I'm developing a registration form in React X with TypeScript 5.0, using React Hook Form. I need to implement an email validation function that uses optimized regular expressions, handles edge cases like IDN domains, and returns structured error objects for integration with our Toast notification system."

What to Include in Your Prompts

• Versions of the technologies (e.g., Node.js v20, React 18)

• Related existing code

• Documentation of relevant libraries

• Error captures if any

• Your end goal and specific requirements

• Desired tone and format for the response

Tip: The best results usually come after several interactions. Don't expect the perfect answer on the first attempt.

Tip: If the response doesn't meet your expectations, reformulate the prompt or ask for clarification: "This doesn't work with Express X.XX, can you adjust it?"

Verify Everything, Always

Don't send code you don't understand. You can't blindly trust code generated by AI; you must review everything line by line, as you would in a code review.

How to Verify Code:

1. Read each line and make sure you understand it completely

2. Check official documentation if it uses methods or libraries you don't know

3. Test the code in a test environment (never directly in production)

4. Use linters like ESLint or Pylint to detect basic errors

5. Write unit tests to confirm it works

Code Analysis Tools

In the era of AI-generated code, these tools are more important than ever:

• Static analyzers (like SonarQube): Examine code without executing it

• Dynamic analyzers: Evaluate code during execution

• Security tools (SAST/DAST): Detect vulnerabilities

• Linters: Check style and conventions

• Complexity analyzers: Measure maintainability metrics

• Coverage tools: Identify parts of the code covered by tests

• Dependency reviewers: Scan third-party libraries

• Architecture visualizers: Generate diagrams of code structure

These tools don't replace code reviews but add a layer of verification to maintain quality and consistency.

Start with Small, Specific Tasks

Instead of requesting complete projects, start with concrete, low-risk tasks that will help you become familiar with AI.

Ideally, discover through experimentation which of your tasks can be "assisted" by AI. It won't necessarily do 100% of the work, but it will help you complete tasks more quickly.

Ideas to Get Started:

Tasks for Planning Software

• "Design the structure of a database table for [description]"

• "Create a flowchart for this process: [description]"

• "Identify main use cases for this feature: [description]"

Tasks for Understanding Code

• "Explain how this code works line by line: [code]"

• "What does this method do, and is there a better alternative?"

Tasks for Improving Code

• "Review this function and tell me what I can improve: [code]"

• "Are there potential problems in this code?: [code]"

Specific Tasks

• "Write documentation for this function in JSDoc format"

• "Create unit tests for this function using Jest"

• "Convert this JavaScript code to TypeScript"

Communication Tasks

• "Translate this technical explanation for a marketing team: [explanation]"

• "Help me explain to non-technical stakeholders why we invested time in refactoring"

These tasks allow you to experiment without compromising important projects.

Use AI as a Learning Companion

AI can accelerate your learning curve and help you master new or complex concepts.

Examples of Learning Prompts

• Complex code: "Explain this PHP code to me, but keep in mind I'm a developer with experience in JavaScript"

• New concepts: "Explain closures in JavaScript with practical examples of real use"

• Techniques: "Review my implementation and suggest more appropriate design patterns"

• Specific topics: "Explain what a middleware is in Express with a practical example"

Practice Pair Programming with AI

Treat AI as a programming partner. An effective workflow:

Example: Creating an Endpoint for User Registration

1. Explain the objective: "I need a POST endpoint in Express that registers users with email and password, using bcrypt to hash the password"

2. Ask for the code: The AI will give you an implementation

3. Ask for alternatives: "Can I use argon2 instead of bcrypt? How would the code change?"

4. Edge cases: "Identify edge cases this code doesn't consider and explain"

5. Review and question: "Explain why you used async/await here"

6. Integrate and test: If errors occur, share the logs: "This endpoint is giving a 500 error, here's the log: [log]"

General Steps:

• Break problems into manageable parts

• Clearly explain your goal for each part

• Request alternatives: "Is there another way to implement this?"

• Question decisions: "Why did you choose this approach?"

• Review and understand each line before integrating it

This method will improve both your code and your technical communication skills.

Expected Results

With consistent practice, you can expect:

• First week: Basic familiarity with prompts and results

• First month: Notable reduction in time for repetitive tasks

• Three months: Natural integration of AI into your daily workflow

• Six months: Ability to tackle complex projects with AI assistance

These timeframes are guidelines. If you use AI daily, you'll see results faster. The key is to experiment consistently.

Important Limitations

AI is powerful but not perfect. Know its limitations:

• Hallucinations: It can invent non-existent methods or APIs. Always verify in official documentation.

• Subtle bugs: The code may appear correct but contain logical or security errors.

• Privacy: Don't share confidential code or sensitive data.

• Dependency: Maintain your problem-solving skills. AI is a tool, not your replacement.

Next Steps

Once you master the basics, you can explore:

• Specialized tools: Cursor (editor with integrated AI) or v0 (for user interfaces)

• Advanced techniques: Advanced prompting or adapting models to your style

• Architecture: Using AI for system design or project planning

• Communities: Specialized forums and blogs for tips and tricks

Summary

1. Set up free tools and experiment with them

2. Write detailed prompts with context for better results

3. Verify all code and use analysis tools

4. Start with small, specific tasks

5. Use AI for learning and team programming

Frequently Asked Questions

Do I need to pay for these tools?
Not initially. You can start with free versions and evaluate paid plans later.

What if AI gives me code I don't understand?
Ask it to explain line by line or consult official documentation.

Is it safe to use AI with my code?
Don't share confidential code. Use test environments and review everything before implementing it.

Conclusion

The hardest part is taking the first step, but each interaction will teach you something new. Maintain an experimental mindset and develop your own style for working with these tools.

Time to start! Open any AI tool right now and try a simple prompt like: "Explain how `forEach` works in JavaScript with an example." The first step is the most important!