Bill Gates disse tudo... seja um programador preguiçoso!.

Como programador, não há nada melhor do que um código que funciona imediatamente – sem bugs, sem depuração interminável. seguindo certas técnicas de prompt, você pode fazer com que o ChatGPT escreva não apenas código, mas código otimizado, totalmente funcional e documentado, completo com casos extremos, testes e até otimizações de desempenho.

Mas primeiro...

O que é engenharia imediata?

Inteligência Artificial, especialmente ChatGPT, tornou-se uma ferramenta poderosa para criação de conteúdo, assistência de codificação e resposta a perguntas complexas. No entanto, muitas pessoas não aproveitam todo o seu potencial. A mágica está na forma como você formula suas solicitações – o que chamamos de engenharia imediata. Neste artigo, exploraremos técnicas que podem tornar sua experiência no ChatGPT mais proveitosa, destacando alguns truques que podem levar suas solicitações de medianas a brilhantes, como programador de software.

Por que a engenharia imediata é importante?

ChatGPT é treinado em grandes quantidades de dados, mas suas respostas são moldadas pela qualidade da solicitação que você fornece. Solicitações mal formuladas ou vagas podem levar a respostas irrelevantes ou genéricas. Por outro lado, prompts bem estruturados podem gerar respostas ponderadas, precisas e criativas.

Este guia ajudará programadores preguiçosos (como eu?) a obter código de alta qualidade, otimizado e ainda mais funcional do ChatGPT usando engenharia imediata. Isso fará com que o ChatGPT faça exclusivamente o trabalho pesado - automatizando a geração de código, melhorando-o e até sugerindo otimizações e testes. Abaixo, também incluí exemplos que comparam os prompts normais com os otimizados e os resultados que eles geram.

Então vamos começar!.

Acionando refinamentos automáticos para um código melhor

Peça ao ChatGPT para refinar automaticamente suas respostas incorporando gatilhos para detectar ineficiências, sugerir otimizações ou adicionar recursos.

Prompt básico: "Escreva uma função Python para reverter uma string."

def reverse_string(s):
    return s[::-1]

# Example usage:
print(reverse_string("hello"))  # Output: "olleh"

Prompt otimizado: "Escreva uma função Python para reverter uma string. Se a entrada for muito grande ou ineficiente, sugira uma maneira melhor de lidar com strings grandes de forma eficiente."

def reverse_string(s):
    return s[::-1]

# Trigger: Refining for large strings
def reverse_large_string(s):
    # Handle large strings in chunks for efficiency
    chunk_size = 100000  # Process in 100k chunks
    return ''.join(s[i:i chunk_size][::-1] for i in range(0, len(s), chunk_size))

# Example usage:
large_string = "a" * 1000000  # 1 million characters
print(reverse_large_string(large_string))

• A função básica é simples e funciona para pequenas entradas.

• O otimizado apresenta uma solução eficiente baseada em blocos para reverter strings grandes sem consumir muita memória.

Memória contextual para projetos de várias etapas

Quando você precisa de código para projetos de várias etapas, o ChatGPT pode se lembrar das etapas anteriores. Isso é ideal para fluxos de trabalho mais complexos, onde você cria uma camada sobre outra.

Prompt básico: "Escreva uma função Python para criar um perfil de usuário."

def create_user_profile(name, age, email):
    return {"name": name, "age": age, "email": email}

# Example usage:
user_profile = create_user_profile("Alice", 30, "[email protected]")
print(user_profile)

Prompt otimizado: "Escreva uma função Python para criar um perfil de usuário. Agora, estenda isso para armazenar também as preferências do usuário e conecte-o a um banco de dados para salvar os perfis."

def create_user_profile(name, age, email, preferences):
    return {"name": name, "age": age, "email": email, "preferences": preferences}

# Extend with a database connection
import sqlite3

def save_user_profile(profile):
    conn = sqlite3.connect('users.db')
    cursor = conn.cursor()
    cursor.execute('''CREATE TABLE IF NOT EXISTS users
                      (name TEXT, age INTEGER, email TEXT, preferences TEXT)''')
    cursor.execute('''INSERT INTO users (name, age, email, preferences)
                      VALUES (?, ?, ?, ?)''', 
                   (profile['name'], profile['age'], profile['email'], str(profile['preferences'])))
    conn.commit()
    conn.close()

# Example usage:
user_profile = create_user_profile("Alice", 30, "[email protected]", {"theme": "dark"})
save_user_profile(user_profile)

• A primeira função do prompt básico cria um perfil de usuário simples.

• O segundo prompt cria um gerenciador de perfil de usuário conectado ao banco de dados com funcionalidade estendida para salvar dados.

Solicitar modo de depuração para código livre de erros

Você pode pedir ao ChatGPT para agir como se estivesse sendo executado no modo de depuração, onde verifica e corrige possíveis problemas no código antes de entregar o resultado final.

Exemplo de prompt simples: "Escreva uma função Python para calcular a raiz quadrada de um número."

import math

def square_root(n):
    return math.sqrt(n)

# Example usage:
print(square_root(16))  # Output: 4.0

O truque: "Escreva uma função Python para calcular a raiz quadrada de um número. Ative o modo de depuração para verificar erros como entradas negativas e reescreva a função se necessário."

import math

def square_root(n):
    if n 

• A função básica funciona bem para entradas válidas, mas falha com números negativos.

• O prompt otimizado garante o tratamento de erros para entradas negativas, retornando uma mensagem personalizada em vez de quebrar o código.

Role-Playing: atue como um revisor de código

Você pode pedir ao ChatGPT para atuar como revisor de código sênior para fornecer feedback e sugerir práticas recomendadas para seu código.

Exemplo de prompt: "Atuar como desenvolvedor sênior e revisar minha função Python que verifica se um número é primo. Sugira melhorias para desempenho e legibilidade."

def is_prime(n):
    if n 



O prompt oferece uma versão mais otimizada, verificando apenas números ímpares até a raiz quadrada, o que melhora drasticamente o desempenho.


  
  
  Use solicitações em camadas para saídas multifuncionais


Você pode empilhar camadas de funcionalidade em um único prompt, pedindo ao ChatGPT para lidar com várias tarefas relacionadas de uma só vez.

Prompt básico: "Escreva uma função Python para gerar uma senha aleatória."



import random
import string

def generate_password(length):
    return ''.join(random.choices(string.ascii_letters   string.digits, k=length))

# Example usage:
print(generate_password(10))  # Output: Random 10-character password




Versão otimizada: "Escreva uma função Python para gerar uma senha aleatória. A senha deve atender aos seguintes critérios: pelo menos 12 caracteres, contém letras maiúsculas, minúsculas, números e caracteres especiais. Além disso, escreva uma função de validação para verificar se a senha é forte."



import random
import string
import re

def generate_password(length):
    characters = string.ascii_letters   string.digits   string.punctuation
    password = ''.join(random.choices(characters, k=length))
    return password

def validate_password(password):
    # Check length
    if len(password) 

• O prompt básico gera uma senha aleatória.

• O otimizado fornece um gerador de senha complexo e inclui uma função de validação para verificar a força da senha.

Desenvolvimento Orientado a Testes: Gere um Conjunto de Testes Completo

Você pode pedir ao ChatGPT para escrever o código junto com um conjunto de testes completo de uma só vez, garantindo que seu código esteja pronto para produção com o mínimo de esforço. (Se precisar pedir ajuda, peça muito?).

Prompt básico: "Escreva uma função Python para verificar se uma string é um palíndromo."

def is_palindrome(s):
    return s == s[::-1]

# Example usage:
print(is_palindrome("madam"))  # Output: True
print(is_palindrome("hello"))  # Output: False

Obtendo mais: "Escreva uma função Python para verificar se uma string é um palíndromo. Além disso, escreva um conjunto de testes completo usando pytest com casos extremos como strings vazias e espaços."

def is_palindrome(s):
    s = ''.join(c.lower() for c in s if c.isalnum())  # Remove non-alphanumeric characters
    return s == s[::-1]

# Test suite
def test_is_palindrome():
    assert is_palindrome("madam") == True
    assert is_palindrome("hello") == False
    assert is_palindrome("A man, a plan, a canal, Panama") == True
    assert is_palindrome("") == True  # Edge case: empty string
    assert is_palindrome(" ") == True  # Edge case: only spaces

# Example usage:
print(is_palindrome("A man, a plan, a canal, Panama"))  # Output: True

• A versão básica verifica palíndromos, mas perde casos extremos.

• O truque oculto não apenas refina a função ignorando espaços e pontuação, mas também fornece um conjunto de testes abrangente usando pytest.

Ao dominar essas técnicas, você pode extrair código de alto desempenho, livre de erros e pronto para produção do ChatGPT, ao mesmo tempo em que realiza menos trabalho. Com refinamentos automáticos, gatilhos de memória, tratamento de erros e conjuntos de testes completos, você codificará de maneira mais inteligente, não mais difícil.