Programando com IA: Jules e Cursor

Setup inteligente com IA - Apresentação

Apresentando o tema e o projeto

Olá! Meu nome é Guilherme Sudeira e estou aqui para discutirmos como agentes remotos de inteligência artificial, mais especificamente agentes, podem nos auxiliar na criação de novos projetos no dia a dia.

Audiodescrição: Guilherme é um homem branco, de cabelo curto castanho, sobrancelhas castanhas, e olhos castanhos. Ele veste uma camisa azul clara e está sentado em um escritório com uma parede branca ao fundo e uma estante com livros à esquerda.

Hoje, vamos iniciar um projeto do zero, no qual teremos salas que podem ser reservadas em determinados períodos de horário. Escolhi este projeto específico para trabalharmos porque quero demonstrar a criação inicial do projeto, onde o conhecimento da pessoa desenvolvedora pode ser mais valioso do que a ajuda da inteligência artificial em alguns momentos, mesmo que remota.

Explorando desafios e funcionalidades

À medida que desenvolvemos, surgirão questões mais complexas, como a forma de representar o agendamento e os horários disponíveis, além de como isso pode ser editado na IDE.

Queremos uma funcionalidade em JavaScript que não seja necessariamente complexa, mas que envolva algum trabalho diferente com a linguagem, algo que talvez não conheçamos tão bem. O objetivo é aprender enquanto criamos essa funcionalidade.

Considerando ferramentas e abordagens

Determinadas linguagens e frameworks que escolhemos e utilizamos em nossa empresa podem influenciar nossa capacidade de desenvolver com mais ou menos potencialidade e qualidade, considerando nossa experiência como pessoas desenvolvedoras.

Podemos utilizar IDEs remotas e inteligências artificiais remotas em conjunto com nossas IDEs que possuem inteligência artificial, além de nossa capacidade de codificar soluções, para potencializar nossos resultados. Precisamos avaliar quando vale a pena utilizar essas ferramentas e quando não vale.

Devemos considerar quando é mais vantajoso trabalhar individualmente, como uma pessoa desenvolvedora com dez dedos, em comparação com uma inteligência artificial em nossa máquina ou em outra máquina, realizando diversas tarefas. Cada abordagem tem suas vantagens e desvantagens.

A vantagem de utilizarmos a Juiz diversas vezes é entender seu potencial e aplicá-la adequadamente.

Setup inteligente com IA - Correção e Ajustes na Aplicação

Iniciando o projeto de gestão de reservas de salas

Vamos iniciar nosso projeto, que consiste na construção de uma aplicação para gestão de reservas de salas. Essa aplicação permitirá cadastrar e configurar salas, entre outras funcionalidades. Utilizaremos Django, Compute Strap e Vanilla JavaScript.

Temos uma descrição geral do projeto, e o primeiro passo é criar o projeto. Para isso, vamos criar um repositório.

Criando o repositório no GitHub

O nosso repositório será chamado de Gestão de Salas. Vamos incluir um único arquivo, que é um .gitignore, pois utilizaremos o Python, que já conhecemos. Escolheremos o .gitignore do Python e criaremos o repositório chamado Gestão de Salas. Esse repositório será baixado para nossa máquina. Em seguida, abriremos com o GitHub, clonaremos e, após clonado, poderemos abrir com nosso editor. Estamos utilizando o Cursor. No Cursor, podemos abrir esse diretório.

Codando com IA - Autenticação no Django

Continuando o projeto e publicando branches

Continuando com nosso projeto, observamos que a Judy já havia terminado um pouco antes de nós. Ela já tinha finalizado a tarefa de publicar um branch. Ao clicar em Publish Branch, um branch é criado no GitHub, permitindo que possamos visualizar, comparar e fazer um pull request. No entanto, é importante ter cuidado, pois o pull request é feito sobre o projeto original. Nesse projeto original, foi criado um diretório chamado "MyProject". Não desejamos ser responsáveis por esse diretório, então decidimos descartar esse branch. Apesar disso, notamos como foi fácil criá-lo. Seja através da nossa IDE, inteligência artificial local, linha de comando ou por meio da Judy, conseguimos criar o projeto, gerar um branch no GitHub e um pull request de forma eficiente.

Agora, queremos criar outras funcionalidades. Precisamos de salas de aula, que devem ter horários de disponibilidade. Esses horários serão armazenados no banco de dados. Por padrão, o Django utiliza o SQLite, e o servidor já está configurado na porta 1800, executando o manage.py runserver. Gostamos de incluir o comando runserver nas instruções de execução, como no arquivo readme, que já contém os passos: instalar, migrar e executar o servidor.

Criando o modelo de dados para salas

Vamos adicionar a funcionalidade das salas. Podemos escolher entre diferentes abordagens, como Julis ou IDF, pois o importante é que cada sala possa registrar seus horários disponíveis por semana, como segunda-feira das 9h às 17h, terça-feira das 9h às 14h, entre outros. Além disso, precisamos criar um sistema de usuários com login e senha. Podemos desenvolver ambas as funcionalidades simultaneamente. Na Julis, podemos solicitar a criação de um modelo de dados chamado sala, que inclui um ID, nome e horários disponíveis. Esses horários podem ser representados de várias formas no banco de dados, como uma matriz de intervalos de inteiros. Optamos por armazenar um campo JSON no modelo sala, com a estrutura: segunda-feira, das 9h às 17h. Vamos padronizar os dias da semana em inglês, como Monday, Tuesday, etc.

Para começar, vamos criar o modelo de dados chamado Sala:

from django.db import models

class Sala(models.Model):
    id = models.AutoField(primary_key=True)
    nome = models.CharField(max_length=100)
    horarios_disponiveis = models.JSONField()

Os horários disponíveis são um campo JSON dentro desse modelo de sala. Por exemplo, o campo JSON pode ter a seguinte estrutura para indicar que está disponível das 9h às 17h:

horarios_disponiveis = {
    'monday': [{'from': 9, 'to': 17}]
}

Desenvolvendo o sistema de login e registro de usuários

Além disso, queremos criar uma página que liste as salas e outra que permita adicionar uma sala. Enquanto isso, na nossa IDE, continuamos trabalhando no sistema de login. Desejamos um sistema de login tradicional do Django, com tela de login, cadastro, e autenticação por usuário e senha. Vamos executar o código, pois as URLs de administração já existem no Django, bastando adicionar as configurações necessárias. Conhecendo o Django, sabemos o que solicitar. Configuramos uma rota para login, utilizando a mesma rota para o formulário de login e logout, além de uma rota para registro de usuário, com métodos post para registrar e get para exibir o formulário. O formulário de criação de usuário já é fornecido pelo Django.

Aqui está a configuração das URLs para o sistema de login:

from django.urls import path
from . import views

urlpatterns = [
    path('login/', views.user_login, name='login'),
    path('logout/', views.user_logout, name='logout'),
    path('register/', views.user_register, name='register'),
    path('dashboard/', views.dashboard, name='dashboard'),
]

E as views correspondentes para login, logout e registro de usuário:

from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required
from django.contrib.auth.forms import UserCreationForm
from django.http import HttpRequest, HttpResponse
from django.shortcuts import render, redirect
from django.contrib import messages

def user_login(request: HttpRequest) -> HttpResponse:
    """View para autenticação de usuário."""
    if request.user.is_authenticated:
        return redirect('webapp:welcome')

    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')

        if username and password:
            user = authenticate(request, username=username, password=password)
            if user is not None:
                login(request, user)
                messages.success(request, f'Bem-vindo, {username}!')
                return redirect('webapp:welcome')
            else:
                messages.error(request, 'Usuário ou senha inválidos.')
        else:
            messages.error(request, 'Por favor, preencha todos os campos.')

    return render(request, 'webapp/login.html')

def user_logout(request: HttpRequest) -> HttpResponse:
    """View para logout do usuário."""
    logout(request)
    messages.success(request, 'Você foi desconectado com sucesso.')
    return redirect('webapp:login')

def user_register(request: HttpRequest) -> HttpResponse:
    """View para cadastro de novo usuário."""
    if request.user.is_authenticated:
        return redirect('webapp:welcome')

    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)
            messages.success(request, 'Conta criada com sucesso!')
            return redirect('webapp:welcome')
        else:
            for error in form.errors.values():
                messages.error(request, error)
    else:
        form = UserCreationForm()
    return render(request, 'webapp/register.html', {'form': form})

@login_required
def dashboard(request: HttpRequest) -> HttpResponse:
    """View do dashboard (apenas para usuários autenticados)."""
    return render(request, 'webapp/dashboard.html')

Configurando o ambiente de desenvolvimento

Criamos um dashboard para usuários autenticados e configuramos todas as URLs necessárias. No arquivo base HTML, adicionamos um navbar com o nome do usuário, dashboard, opções de entrar e se cadastrar. No arquivo de login HTML, criamos o formulário de cadastro. Ainda não havíamos aprovado o plano para as salas, mas agora definimos o modelo, implementamos as views e configuramos as URLs.

Nosso projeto de gestão de salas está em andamento, com duas tarefas na Julis. Podemos definir um setup inicial, que inclui rodar o pip install-requirements. Esse processo é armazenado como uma imagem, similar a uma dockerização, permitindo que as tarefas sejam inicializadas mais rapidamente. Isso evita a necessidade de adivinhar que o pip install-requirements deve ser executado a cada vez.

Após rodarmos o comando pip install -r requirements.txt, não será mais necessário adivinhar, pois já executamos a instalação das dependências. Retornamos ao terminal e parece que o processo já foi concluído. O comando edit não funcionou, então ele está recriando e atualizando o arquivo MD. Não sabemos exatamente o que será atualizado, mas acreditamos que possa ser algo relacionado às rotas. Vamos aguardar a conclusão.

Testando e corrigindo problemas no sistema

Lembramos daquela situação de ficar parado, que não apreciamos. Preferimos estar sempre trabalhando. Aqui, o sistema está criando o modelo de sala e finalizando o sistema. O servidor caiu em um dos terminais, mas continua rodando em outro. O cursor não percebeu que já estava em execução e tentou rodar novamente, mas o sistema já está funcionando.

Vamos criar um arquivo de teste. Foi decidido criar esse arquivo e verificamos que tudo está parcialmente correto, exceto por um problema de disallow de host. O sistema está verificando que o comando runserver já está em execução. Vamos testar localmente enquanto o sistema cria a sala no ambiente de teste. Atualizamos a página, pois a atualização não estava rápida. Durante esse processo, o sistema está criando a migração da tabela de sala com campos como id, nome e horas disponíveis. Foram criados o modelo de sala, a edge room para adicionar uma sala, uma lista de salas e as views correspondentes. Tudo está sendo configurado e finalizado.

Enquanto isso, testamos a página. Fizemos login e criamos uma conta com o usuário Guilherme.Silveira e uma senha. Optamos por usar um nome de usuário como "gestão de salas" para facilitar a memorização e evitar redigitar a senha constantemente. Após o login, o sistema já mostra que estamos logados como "gestão de salas". Enquanto isso, outra pessoa está trabalhando em paralelo. Atualizamos e os testes estão rodando. Parece que tudo está encaminhado, com as URLs para adicionar e listar salas já configuradas.

Resolvendo bugs e conflitos

Infelizmente, o sistema apresentou um bug e não está atualizando automaticamente, sendo necessário atualizar manualmente. Apesar disso, temos um dashboard que, embora não faça sentido, suporta login. Vamos acessar o modo privado com Ctrl + Shift + N e tentar acessar a URI. O sistema pediu login, o que indica que a proteção já está ativa.

No entanto, algumas funcionalidades, como a criação de novas salas, não estão funcionando corretamente. O sistema está inventando funcionalidades que não foram solicitadas. Para resolver isso, vamos criar um arquivo chamado agents.mb e definir que o sistema não deve inventar links ou funcionalidades não solicitadas. Infelizmente, o nosso sistema atual, o cursor, não lê o agents.mb, mas podemos configurá-lo para que o faça.

No cursor, adicionamos uma regra para sempre ler o agents.mb antes de executar qualquer ação. Salvamos essa configuração, garantindo que todas as inteligências artificiais, como o Gemini, leiam o arquivo agents.mb. Nesse arquivo, colocaremos nossas práticas de trabalho e regras de código.

Finalizando o projeto e integrando funcionalidades

Após finalizar os testes, verificamos o código e criamos um pull request para o branch room management. Durante o processo, encontramos um conflito, pois enquanto criávamos a autenticação localmente, o sistema remoto criou as salas. Resolvemos o conflito, que era simples, e fizemos o merge.

A vantagem de ter alguém executando tarefas em paralelo é evidente. Enquanto programamos uma funcionalidade, outra pessoa pode programar outra, e ambas podem ser integradas rapidamente. Após resolver as diferenças, rodamos a migração do banco de dados com python manage.py migrate. O servidor está funcionando e podemos acessar o sistema.

Ao acessar localhost:8000, encontramos um problema com a rota edroom, que não foi encontrada. Precisamos verificar o arquivo urls para entender o motivo desse erro.

Sobre o curso Programando com IA: Jules e Cursor

O curso Programando com IA: Jules e Cursor possui 77 minutos de vídeos, em um total de 26 atividades. Gostou? Conheça nossos outros cursos de IA para Programação em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Setup inteligente com IA
• Codando com IA
• Boas práticas automatizadas
• Interface com IA
• Segurança e entrega final
• Paralelismo e Automação